(* Title:  Tactics; tac_ for interaction with frontend, input for internal use.

   Author: Walther Neuper 170121

   (c) due to copyright terms

regular expression for search:

Add_Find|Add_Given|Add_Relation|Apply_Assumption|Apply_Method|Begin_Sequ|Begin_Trans|Split_And|Split_Or|Split_Intersect|Conclude_And|Conclude_Or|Collect_Trues|End_Sequ|End_Trans|End_Ruleset|End_Subproblem|End_Intersect|End_Proof|CAScmd|Calculate|Check_Postcond|Check_elementwise|Del_Find|Del_Given|Del_Relation|Derive|Detail_Set|Detail_Set_Inst|End_Detail|Empty_Tac|Free_Solve|Init_Proof|Model_Problem Or_to_List|Refine_Problem|Refine_Tacitly| Rewrite|Rewrite_Inst|Rewrite_Set|Rewrite_Set_Inst|Specify_Method|Specify_Problem|Specify_Theory|Subproblem|Substitute|Tac|Take|Take_Inst

*)

signature TACTIC =

sig

  datatype T = datatype Tactic_Def.T

  val string_of: T -> string

  datatype input = datatype Tactic_Def.input

  val tac2str : input -> string

  val tac2IDstr : input -> string

  val is_empty_tac : input -> bool

(*//-------------------------------------------------------------- only AFTER ctree.sml required *)

  val eq_tac : input * input -> bool

  val is_rewtac : input -> bool

  val is_rewset : input -> bool

  val rls_of : input -> Rule.rls'

  val rule2tac : theory -> (term * term) list ->  Rule.rule -> input

  val input_from_T : T -> input

  val result : T -> term

  val creates_assms: T -> term list

  val insert_assumptions: T -> Proof.context -> Proof.context

  val for_specify: input -> bool

  val for_specify': T -> bool

(* ---- for tests only: shifted from below to remove the Warning "unused" at fun.def. --------- *)

  (* NONE *)

(*/-------------------------------------------------------- ! aktivate for Test_Isac BEGIN ---\* )

  (* NONE *)

( *\--- ! aktivate for Test_Isac END ----------------------------------------------------------/*)

(*----- unused code, kept as hints to design ideas ---------------------------------------------*)

  (* NONE *)

end

(**)

structure Tactic(**): TACTIC(**) =

struct

(**)

datatype input = datatype Tactic_Def.input

val tac2str = Tactic_Def.tac2str

val tac2IDstr = Tactic_Def.tac2IDstr

val is_empty_tac = Tactic_Def.is_empty_tac

fun eq_tac (Rewrite (id1, _), Rewrite (id2, _)) = id1 = id2

  | eq_tac (Rewrite_Inst (_, (id1, _)), Rewrite_Inst (_, (id2, _))) = id1 = id2

  | eq_tac (Rewrite_Set id1, Rewrite_Set id2) = id1 = id2

  | eq_tac (Rewrite_Set_Inst (_, id1), Rewrite_Set_Inst (_, id2)) = id1 = id2

  | eq_tac (Calculate id1, Calculate id2) = id1 = id2

  | eq_tac _ = false

fun is_rewset (Rewrite_Set_Inst _) = true

  | is_rewset (Rewrite_Set _) = true 

  | is_rewset _ = false;

fun is_rewtac (Rewrite _) = true

  | is_rewtac (Rewrite_Inst _) = true

  | is_rewtac input = is_rewset input;

fun rls_of (Rewrite_Set_Inst (_, rls)) = rls

  | rls_of (Rewrite_Set rls) = rls

  | rls_of input = error ("rls_of: called with input \"" ^ Tactic_Def.tac2IDstr input ^ "\"");

fun rule2tac thy _ (Rule.Num_Calc (opID, _)) = Calculate (assoc_calc thy opID)

  | rule2tac _ [] (Rule.Thm thm'') = Rewrite thm''

  | rule2tac _ subst (Rule.Thm thm'') = 

    Rewrite_Inst (Selem.subst2subs subst, thm'')

  | rule2tac _ [] (Rule.Rls_ rls) = Rewrite_Set (Rule.id_rls rls)

  | rule2tac _ subst (Rule.Rls_ rls) = 

    Rewrite_Set_Inst (Selem.subst2subs subst, (Rule.id_rls rls))

  | rule2tac _ _ rule = 

    error ("rule2tac: called with \"" ^ Rule.rule2str rule ^ "\"");

  datatype T = datatype Tactic_Def.T

val string_of = Tactic_Def.string_of

fun input_from_T (Refine_Tacitly' (pI, _, _, _, _)) = Refine_Tacitly pI

  | input_from_T (Model_Problem' (_, _, _)) = Model_Problem

  | input_from_T (Add_Given' (t, _)) = Add_Given t

  | input_from_T (Add_Find' (t, _)) = Add_Find t

  | input_from_T (Add_Relation' (t, _)) = Add_Relation t

  | input_from_T (Specify_Theory' dI) = Specify_Theory dI

  | input_from_T (Specify_Problem' (dI, _)) = Specify_Problem dI

  | input_from_T (Specify_Method' (dI, _, _)) = Specify_Method dI

  | input_from_T (Rewrite' (_, _, _, _, thm, _, _)) = Rewrite thm

  | input_from_T (Rewrite_Inst' (_, _, _, _, sub, thm, _, _)) = Rewrite_Inst (Selem.subst2subs sub, thm)

  | input_from_T (Rewrite_Set' (_, _, rls, _, _)) = Rewrite_Set (Rule.id_rls rls)

  | input_from_T (Detail_Set' (_, _, rls, _, _)) = Detail_Set (Rule.id_rls rls)

  | input_from_T (Rewrite_Set_Inst' (_, _, sub, rls, _, _)) = 

    Rewrite_Set_Inst (Selem.subst2subs sub, Rule.id_rls rls)

  | input_from_T (Detail_Set_Inst' (_, _, sub, rls, _, _)) = 

    Detail_Set_Inst (Selem.subst2subs sub, Rule.id_rls rls)

  | input_from_T (Calculate' (_, op_, _, _)) = Calculate (op_)

  | input_from_T (Check_elementwise' (_, pred, _)) = Check_elementwise pred

  | input_from_T (Or_to_List' _) = Or_to_List

  | input_from_T (Take' term) = Take (Rule.term2str term)

  | input_from_T (Substitute' (_, _, subte, _, _)) = Substitute (Selem.subte2sube subte) 

  | input_from_T (Tac_ (_, _, id, _)) = Tac id

  | input_from_T (Subproblem' ((domID, pblID, _), _, _, _,_ ,_)) = Subproblem (domID, pblID)

  | input_from_T (Check_Postcond' (pblID, _)) = Check_Postcond pblID

  | input_from_T Empty_Tac_ = Empty_Tac

  | input_from_T m = raise ERROR (": not impl. for "^(Tactic_Def.string_of m));

fun res (Rewrite_Inst' (_ , _, _, _, _, _, _, res)) = res

  | res (Rewrite' (_, _, _, _, _, _, res)) = res

  | res (Rewrite_Set_Inst' (_, _, _, _, _, res)) = res

  | res (Rewrite_Set' (_, _, _, _, res)) = res

  | res (Calculate' (_, _, _, (t, _))) = (t, [])

  | res (Check_elementwise' (_, _, res)) = res

  | res (Subproblem' (_, _, _, _, _, t)) = (t, [])

  | res (Take' t) = (t, [])

  | res (Substitute' (_, _, _, _, t)) = (t, [])

  | res (Or_to_List' (_,  t)) = (t, [])

  | res m = raise ERROR ("result: not impl.for " ^ Tactic_Def.string_of m)

(*fun result m = (fst o res) m; TODO*)

fun result tac = (fst o res) tac;

fun creates_assms tac = (snd o res) tac;

fun insert_assumptions tac ctxt  = ContextC.insert_assumptions (creates_assms tac) ctxt

fun for_specify (Init_Proof _) = true

  | for_specify Model_Problem  = true

  | for_specify (Refine_Tacitly _) = true

  | for_specify (Refine_Problem _) = true

  | for_specify (Add_Given _) = true

  | for_specify (Del_Given _) = true

  | for_specify (Add_Find _) = true

  | for_specify (Del_Find _) = true

  | for_specify (Add_Relation _) = true

  | for_specify (Del_Relation _) = true

  | for_specify (Specify_Theory _) = true

  | for_specify (Specify_Problem _) = true

  | for_specify (Specify_Method _) = true

  | for_specify _ = false

fun for_specify' (Init_Proof' _) = true

  | for_specify' (Model_Problem' _) = true

  | for_specify' (Refine_Tacitly' _) = true

  | for_specify' (Refine_Problem' _) = true

  | for_specify' (Add_Given' _) = true

  | for_specify' (Del_Given' _) = true

  | for_specify' (Add_Find' _) = true

  | for_specify' (Del_Find' _) = true

  | for_specify' (Add_Relation' _) = true

  | for_specify' (Del_Relation' _) = true

  | for_specify' (Specify_Theory' _) = true

  | for_specify' (Specify_Problem' _) = true

  | for_specify' (Specify_Method' _) = true

  | for_specify' _ = false

(**)end(**)