(* 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_Asm|Rewrite_Inst|Rewrite_Set|Rewrite_Set_Inst|Specify_Method|Specify_Problem|Specify_Theory|Subproblem|Substitute|Tac|Take|Take_Inst

*)

signature TACTIC =

sig

  datatype T =

    Add_Find' of Rule.cterm' * Model.itm list | Add_Given' of Rule.cterm' * Model.itm list 

  | Add_Relation' of Rule.cterm' * Model.itm list

  | Apply_Assumption' of term list * term

  | Apply_Method' of Celem.metID * term option * Istate.T * Proof.context

  | Begin_Sequ' | Begin_Trans' of term

  | Split_And' of term | Split_Or' of term | Split_Intersect' of term

  | Conclude_And' of term | Conclude_Or' of term | Collect_Trues' of term

  | End_Sequ' | End_Trans' of Selem.result

  | End_Ruleset' of term | End_Subproblem' of term | End_Intersect' of term | End_Proof''

  | CAScmd' of term

  | Calculate' of Rule.theory' * string * term * (term * Celem.thm')

  | Check_Postcond' of Celem.pblID * Selem.result

  | Check_elementwise' of term * Rule.cterm' * Selem.result

  | Del_Find' of Rule.cterm' | Del_Given' of Rule.cterm' | Del_Relation' of Rule.cterm'

  | Derive' of Rule.rls

  | Detail_Set' of Rule.theory' * bool * Rule.rls * term * Selem.result

  | Detail_Set_Inst' of Rule.theory' * bool * Rule.subst * Rule.rls * term * Selem.result

  | End_Detail' of Selem.result

  | Empty_Tac_

  | Free_Solve'

  | Init_Proof' of Rule.cterm' list * Celem.spec

  | Model_Problem' of Celem.pblID * Model.itm list * Model.itm list

  | Or_to_List' of term * term

  | Refine_Problem' of Celem.pblID * (Model.itm list * (bool * term) list)

  | Refine_Tacitly' of Celem.pblID * Celem.pblID * Rule.domID * Celem.metID * Model.itm list

  | Rewrite' of Rule.theory' * Rule.rew_ord' * Rule.rls * bool * Celem.thm'' * term * Selem.result

  | Rewrite_Asm' of Rule.theory' * Rule.rew_ord' * Rule.rls * bool * Celem.thm'' * term * Selem.result

  | Rewrite_Inst' of Rule.theory' * Rule.rew_ord' * Rule.rls * bool * Rule.subst * Celem.thm'' * term * Selem.result

  | Rewrite_Set' of Rule.theory' * bool * Rule.rls * term * Selem.result

  | Rewrite_Set_Inst' of Rule.theory' * bool * Rule.subst * Rule.rls * term * Selem.result

  | Specify_Method' of Celem.metID * Model.ori list * Model.itm list

  | Specify_Problem' of Celem.pblID * (bool * (Model.itm list * (bool * term) list))

  | Specify_Theory' of Rule.domID

  | Subproblem' of Celem.spec * Model.ori list * term * Selem.fmz_ * Proof.context * term

  | Substitute' of Rule.rew_ord_ * Rule.rls * Selem.subte * term * term

  | Tac_ of theory * string * string * string

  | Take' of term | Take_Inst' of term

  val tac_2str : T -> string

  datatype input =

    Add_Find of Rule.cterm' | Add_Given of Rule.cterm' | Add_Relation of Rule.cterm'

  | Apply_Assumption of Rule.cterm' list

  | Apply_Method of Celem.metID

  (*/--- TODO: re-design ? -----------------------------------------------------------------\*)

  | 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'

  (*\--- TODO: re-design ? -----------------------------------------------------------------/*)

  | CAScmd of Rule.cterm'

  | Calculate of string

  | Check_Postcond of Celem.pblID

  | Check_elementwise of Rule.cterm'

  | Del_Find of Rule.cterm' | Del_Given of Rule.cterm' | Del_Relation of Rule.cterm'

  | Derive of Rule.rls'

  | Detail_Set of Rule.rls'

  | Detail_Set_Inst of Selem.subs * Rule.rls'

  | End_Detail

  | Empty_Tac

  | Free_Solve

  | Init_Proof of Rule.cterm' list * Celem.spec

  | Model_Problem

  | Or_to_List

  | Refine_Problem of Celem.pblID

  | Refine_Tacitly of Celem.pblID

  | Rewrite of Celem.thm''

  | Rewrite_Asm of Celem.thm''

  | Rewrite_Inst of Selem.subs * Celem.thm''

  | Rewrite_Set of Rule.rls'

  | Rewrite_Set_Inst of Selem.subs * Rule.rls'

  | Specify_Method of Celem.metID

  | Specify_Problem of Celem.pblID

  | Specify_Theory of Rule.domID

  | Subproblem of Rule.domID * Celem.pblID

  | Substitute of Selem.sube

  | Tac of string

  | Take of Rule.cterm' | Take_Inst of Rule.cterm'

  val tac2str : input -> string

  val eq_tac : input * input -> bool                                              (* for script.sml *)

  val is_empty_tac : input -> bool                                              (* also for tests *)

  val is_rewtac : input -> bool                                              (* for interface.sml *)

  val is_rewset : input -> bool                                             (* for mathengine.sml *)

  val rls_of : input -> Rule.rls'                                               (* for solve.sml *)

  val tac2IDstr : input -> string

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

  val input_from_T : T -> input

(* ---- 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

(* tactics for user at front-end.

   input propagates the construction of the calc-tree;

   there are

   (a) 'specsteps' for the specify-phase, and others for the solve-phase

   (b) those of the solve-phase are 'initac's and others;

       initacs start with a formula different from the preceding formula.

   see 'type tac_' for the internal representation of tactics

*)

datatype input =

    Add_Find of Rule.cterm' | Add_Given of Rule.cterm' | Add_Relation of Rule.cterm'

  | Apply_Assumption of Rule.cterm' list

  | Apply_Method of Celem.metID

    (* creates an "istate" in PblObj.env; in case of "init_form" 

      creates a formula at ((lev_on o lev_dn) p, Frm) and in this "ppobj.loc"

      a "SOME istate" at fst of "loc".

      As each step (in the solve-phase) has a resulting formula (at the front-end)

      Apply_Method also does the 1st step in the script (an "initac") if there is no "init_form" *)  

  (*/--- TODO: re-design ? -----------------------------------------------------------------\*)

  | Begin_Sequ | Begin_Trans

  | Split_And | Split_Or | Split_Intersect

  | Conclude_And | Conclude_Or | Collect_Trues

  | End_Sequ | End_Trans

  | End_Ruleset | End_Subproblem (* WN0509 drop *) | End_Intersect | End_Proof'

  (*\--- TODO: re-design ? -----------------------------------------------------------------/*)

  | CAScmd of Rule.cterm'

  | Calculate of string

  | Check_Postcond of Celem.pblID

  | Check_elementwise of Rule.cterm'

  | Del_Find of Rule.cterm' | Del_Given of Rule.cterm' | Del_Relation of Rule.cterm'

  | Derive of Rule.rls'                 (* WN0509 drop *)

  | Detail_Set of Rule.rls'             (* WN0509 drop *)

  | Detail_Set_Inst of Selem.subs * Rule.rls' (* WN0509 drop *)

  | End_Detail                     (* WN0509 drop *)

  | Empty_Tac

  | Free_Solve

  | Init_Proof of Rule.cterm' list * Celem.spec

  | Model_Problem

  | Or_to_List

  | Refine_Problem of Celem.pblID

  | Refine_Tacitly of Celem.pblID

   (* rewrite-tactics can transport a (thmID, thm) to and (!) from the java-front-end

     because there all the thms are present with both (thmID, thm)

     (where user-views can show both or only one of (thmID, thm)),

     and thm is created from ThmID by assoc_thm'' when entering isabisac *)

  | Rewrite of Celem.thm''

  | Rewrite_Asm of Celem.thm''

  | Rewrite_Inst of Selem.subs * Celem.thm''

  | Rewrite_Set of Rule.rls'

  | Rewrite_Set_Inst of Selem.subs * Rule.rls'

  | Specify_Method of Celem.metID

  | Specify_Problem of Celem.pblID

  | Specify_Theory of Rule.domID

  | Subproblem of Rule.domID * Celem.pblID (* WN0509 drop *)

  | Substitute of Selem.sube

  | Tac of string               (* WN0509 drop *)

  | Take of Rule.cterm' | Take_Inst of Rule.cterm'

fun tac2str ma = case ma of

    Init_Proof (ppc, spec)  => 

      "Init_Proof "^(pair2str (strs2str ppc, Celem.spec2str spec))

  | Model_Problem           => "Model_Problem "

  | Refine_Tacitly pblID    => "Refine_Tacitly " ^ strs2str pblID 

  | Refine_Problem pblID    => "Refine_Problem " ^ strs2str pblID 

  | Add_Given cterm'        => "Add_Given " ^ cterm'

  | Del_Given cterm'        => "Del_Given " ^ cterm'

  | Add_Find cterm'         => "Add_Find " ^ cterm'

  | Del_Find cterm'         => "Del_Find " ^ cterm'

  | Add_Relation cterm'     => "Add_Relation " ^ cterm'

  | Del_Relation cterm'     => "Del_Relation " ^ cterm'

  | Specify_Theory domID    => "Specify_Theory " ^ quote domID

  | Specify_Problem pblID   => "Specify_Problem " ^ strs2str pblID

  | Specify_Method metID    => "Specify_Method " ^ strs2str metID

  | Apply_Method metID      => "Apply_Method " ^ strs2str metID

  | Check_Postcond pblID    => "Check_Postcond " ^ strs2str pblID

  | Free_Solve              => "Free_Solve"

  | Rewrite_Inst (subs, (id, thm)) =>

    "Rewrite_Inst " ^ (pair2str (subs2str subs, spair2str (id, thm |> Thm.prop_of |> Rule.term2str)))

  | Rewrite (id, thm) => "Rewrite " ^ spair2str (id, thm |> Thm.prop_of |> Rule.term2str)

  | Rewrite_Asm (id, thm) => "Rewrite_Asm " ^ spair2str (id, thm |> Thm.prop_of |> Rule.term2str)

  | Rewrite_Set_Inst (subs, rls) => 

    "Rewrite_Set_Inst " ^ pair2str (subs2str subs, quote rls)

  | Rewrite_Set rls         => "Rewrite_Set " ^ quote rls

  | Detail_Set rls          => "Detail_Set " ^ quote rls

  | Detail_Set_Inst (subs, rls) =>  "Detail_Set_Inst " ^ pair2str (subs2str subs, quote rls)

  | End_Detail              => "End_Detail"

  | Derive rls'             => "Derive " ^ rls' 

  | Calculate op_           => "Calculate " ^ op_ 

  | Substitute sube         => "Substitute " ^ Selem.sube2str sube	     

  | Apply_Assumption ct's   => "Apply_Assumption " ^ strs2str ct's

  | Take cterm'             => "Take " ^ quote cterm'

  | Take_Inst cterm'        => "Take_Inst " ^ quote cterm'

  | Subproblem (domID, pblID) => "Subproblem " ^ pair2str (domID, strs2str pblID)

  | End_Subproblem          => "End_Subproblem"

  | CAScmd cterm'           => "CAScmd " ^ quote cterm'

  | Check_elementwise cterm'=> "Check_elementwise " ^ quote cterm'

  | Or_to_List              => "Or_to_List "

  | Collect_Trues           => "Collect_Trues"

  | Empty_Tac               => "Empty_Tac"

  | Tac string              => "Tac " ^ string

  | End_Proof'              => "input End_Proof'"

  | _                       => "tac2str not impl. for ?!";

fun is_empty_tac input = case input of Empty_Tac => true | _ => false

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 (Rewrite_Asm _) = true

  | is_rewtac input = is_rewset input;

fun tac2IDstr ma = case ma of

    Model_Problem => "Model_Problem"

  | Refine_Tacitly _ => "Refine_Tacitly"

  | Refine_Problem _ => "Refine_Problem"

  | Add_Given _ => "Add_Given"

  | Del_Given _ => "Del_Given"

  | Add_Find _ => "Add_Find"

  | Del_Find _ => "Del_Find"

  | Add_Relation _ => "Add_Relation"

  | Del_Relation _ => "Del_Relation"

  | Specify_Theory _ => "Specify_Theory"

  | Specify_Problem _ => "Specify_Problem"

  | Specify_Method _ => "Specify_Method"

  | Apply_Method _ => "Apply_Method"

  | Check_Postcond _ => "Check_Postcond"

  | Free_Solve => "Free_Solve"

  | Rewrite_Inst _ => "Rewrite_Inst"

  | Rewrite _ => "Rewrite"

  | Rewrite_Asm _ => "Rewrite_Asm"

  | Rewrite_Set_Inst _ => "Rewrite_Set_Inst"

  | Rewrite_Set _ => "Rewrite_Set"

  | Detail_Set _ => "Detail_Set"

  | Detail_Set_Inst _ => "Detail_Set_Inst"

  | Derive _ => "Derive "

  | Calculate _ => "Calculate "

  | Substitute _ => "Substitute" 

  | Apply_Assumption _ => "Apply_Assumption"

  | Take _ => "Take"

  | Take_Inst _ => "Take_Inst"

  | Subproblem _ => "Subproblem"

  | End_Subproblem => "End_Subproblem"

  | CAScmd _ => "CAScmd"

  | Check_elementwise _ => "Check_elementwise"

  | Or_to_List => "Or_to_List "

  | Collect_Trues => "Collect_Trues"

  | Empty_Tac => "Empty_Tac"

  | Tac _ => "Tac "

  | End_Proof' => "End_Proof'"

  | _ => "tac2str not impl. for ?!";

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

  | rls_of (Rewrite_Set rls) = rls

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

fun rule2tac thy _ (Rule.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 ^ "\"");

(* tactics for for internal use, compare "input" for user at the front-end.

  tac_ contains results from check in 'fun applicable_in'.

  This is useful for costly results, e.g. from rewriting;

  however, these results might be changed by Scripts like

      "      eq = (Rewrite_Set ''ansatz_rls'' False) eql;" ^

      "      eq = (Rewrite_Set equival_trans False) eq;" ^

  TODO.WN120106 ANALOGOUSLY TO Substitute':

  So tac_ contains the term t the result was calculated from

  in order to compare t with t' possibly changed by "Expr "

  and re-calculate result if t<>t'

  TODO.WN161219: replace *every* cterm' by term

*)

  datatype T =

    Add_Find' of Rule.cterm' * Model.itm list | Add_Given' of Rule.cterm' * Model.itm list 

  | Add_Relation' of Rule.cterm' * Model.itm list

  | Apply_Assumption' of term list * term

  | Apply_Method' of Celem.metID * term option * Istate.T * Proof.context

  (*/--- TODO: re-design ? -----------------------------------------------------------------\*)

  | Begin_Sequ' | Begin_Trans' of term

  | Split_And' of term | Split_Or' of term | Split_Intersect' of term

  | Conclude_And' of term | Conclude_Or' of term | Collect_Trues' of term

  | End_Sequ' | End_Trans' of Selem.result

  | End_Ruleset' of term | End_Subproblem' of term | End_Intersect' of term | End_Proof''

  (*\--- TODO: re-design ? -----------------------------------------------------------------/*)

  | CAScmd' of term

  | Calculate' of Rule.theory' * string * term * (term * Celem.thm')

  | Check_Postcond' of Celem.pblID *

    Selem.result (* returnvalue of script in solve *)

  | Check_elementwise' of (*special case:*)

    term *       (* (1) the current formula: [x=1,x=...]     *)

    string *     (* (2) the pred from Check_elementwise      *)

    Selem.result (* (3) composed from (1) and (2): {x. pred} *)

  | Del_Find' of Rule.cterm' | Del_Given' of Rule.cterm' | Del_Relation' of Rule.cterm'

  | Derive' of Rule.rls

  | Detail_Set' of Rule.theory' * bool * Rule.rls * term * Selem.result

  | Detail_Set_Inst' of Rule.theory' * bool * Rule.subst * Rule.rls * term * Selem.result

  | End_Detail' of Selem.result

  | Empty_Tac_

  | Free_Solve'

  | Init_Proof' of Rule.cterm' list * Celem.spec

  | Model_Problem' of Celem.pblID * 

    Model.itm list *  (* the 'untouched' pbl        *)

    Model.itm list    (* the casually completed met *)

  | Or_to_List' of term * term

  | Refine_Problem' of Celem.pblID * (Model.itm list * (bool * term) list)

  | Refine_Tacitly' of

    Celem.pblID *     (* input*)

    Celem.pblID *     (* the refined from applicable_in                                       *)

    Rule.domID *     (* from new pbt?! filled in specify                                     *)

    Celem.metID *     (* from new pbt?! filled in specify                                     *)

    Model.itm list    (* drop ! 9.03: remains [] for Model_Problem recognizing its activation *)

  | Rewrite' of Rule.theory' * Rule.rew_ord' * Rule.rls * bool * Celem.thm'' * term * Selem.result

  | Rewrite_Asm' of Rule.theory' * Rule.rew_ord' * Rule.rls * bool * Celem.thm'' * term * Selem.result

  | Rewrite_Inst' of Rule.theory' * Rule.rew_ord' * Rule.rls * bool * Rule.subst * Celem.thm'' * term * Selem.result

  | Rewrite_Set' of Rule.theory' * bool * Rule.rls * term * Selem.result

  | Rewrite_Set_Inst' of Rule.theory' * bool * Rule.subst * Rule.rls * term * Selem.result

  | Specify_Method' of Celem.metID * Model.ori list * Model.itm list

  | Specify_Problem' of Celem.pblID * 

    (bool *                  (* matches	                                  *)

      (Model.itm list *      (* ppc	                                      *)

        (bool * term) list)) (* preconditions                             *)

  | Specify_Theory' of Rule.domID

  | Subproblem' of

    Celem.spec * 

		(Model.ori list) *       (* filled in associate Subproblem'           *)

		term *                   (* filled -"-, headline of calc-head         *)

		Selem.fmz_ *             

    Proof.context *          (* DEPRECATED shifted into loc for all ppobj *)

		term                     (* Subproblem (thyID, pbl) OR cascmd         *)  

  | Substitute' of           

    Rule.rew_ord_ *          (* for re-calculation                        *)

    Rule.rls *               (* for re-calculation                        *)

    Selem.subte *            (* the 'substitution': terms of type bool    *)

    term *                   (* to be substituted into                    *)

    term                     (* resulting from the substitution           *)

  | Tac_ of theory * string * string * string

  | Take' of term | Take_Inst' of term

fun tac_2str ma = case ma of

    Init_Proof' (ppc, spec)  => "Init_Proof' " ^ pair2str (strs2str ppc, Celem.spec2str spec)

  | Model_Problem' (pblID, _, _) => "Model_Problem' " ^ strs2str pblID

  | Refine_Tacitly'(p, prefin, domID, metID, _) => "Refine_Tacitly' (" ^ strs2str p ^ ", " ^

    strs2str prefin ^ ", " ^ domID ^ ", " ^ strs2str metID ^ ", pbl-itms)"

  | Refine_Problem' _ => "Refine_Problem' (" ^ (*matchs2str ms*)"..." ^ ")"

  | Add_Given' _ => "Add_Given' "(*^cterm'*)

  | Del_Given' _ => "Del_Given' "(*^cterm'*)

  | Add_Find' _ => "Add_Find' "(*^cterm'*)

  | Del_Find' _ => "Del_Find' "(*^cterm'*)

  | Add_Relation' _ => "Add_Relation' "(*^cterm'*)

  | Del_Relation' _ => "Del_Relation' "(*^cterm'*)

  | Specify_Theory' domID => "Specify_Theory' " ^ quote domID

  | Specify_Problem' (pI, (ok, _)) =>  "Specify_Problem' " ^ 

    spair2str (strs2str pI, spair2str (bool2str ok, spair2str ("itms2str_ itms", "items2str pre")))

  | Specify_Method' (pI, oris, _) => "Specify_Method' (" ^ 

    Celem.metID2str pI ^ ", " ^ Model.oris2str oris ^ ", )"

  | Apply_Method' (metID, _, _, _) => "Apply_Method' " ^ strs2str metID

  | Check_Postcond' (pblID, (scval, asm)) => "Check_Postcond' " ^

      (spair2str (strs2str pblID, spair2str (Rule.term2str scval, Rule.terms2str asm)))

  | Free_Solve' => "Free_Solve'"

  | Rewrite_Inst' (*subs,thm'*) _ => "Rewrite_Inst' "(*^(pair2str (subs2str subs, spair2str thm'))*)

  | Rewrite' _(*thm'*) => "Rewrite' "(*^(spair2str thm')*)

  | Rewrite_Asm' _(*thm'*) => "Rewrite_Asm' "(*^(spair2str thm')*)

  | Rewrite_Set_Inst' _(*subs,thm'*) => "Rewrite_Set_Inst' "(*^(pair2str (subs2str subs, quote rls))*)

  | Rewrite_Set' (thy', pasm, rls', f, (f', asm)) => "Rewrite_Set' (" ^ thy' ^ "," ^ bool2str pasm ^

    "," ^ Rule.id_rls rls' ^ "," ^ Rule.term2str f ^ ",(" ^ Rule.term2str f' ^ "," ^ Rule.terms2str asm ^ "))"

  | End_Detail' _ => "End_Detail' xxx"

  | Detail_Set' _ => "Detail_Set' xxx"

  | Detail_Set_Inst' _ => "Detail_Set_Inst' xxx"

  | Derive' rls => "Derive' " ^ Rule.id_rls rls

  | Calculate'  _ => "Calculate' "

  | Substitute' _ => "Substitute' "(*^(subs2str subs)*)    

  | Apply_Assumption' _(* ct's*) => "Apply_Assumption' "(*^(strs2str ct's)*)

  | Take' _(*cterm'*) => "Take' "(*^(quote cterm'	)*)

  | Take_Inst' _(*cterm'*) => "Take_Inst' "(*^(quote cterm' )*)

  | Subproblem' _(*(spec, oris, _, _, _, pbl_form)*) => 

    "Subproblem' "(*^(pair2str (domID, strs2str ,))*)

  | End_Subproblem' _ => "End_Subproblem'"

  | CAScmd' _(*cterm'*) => "CAScmd' "(*^(quote cterm')*)

  | Empty_Tac_ => "Empty_Tac_"

  | Tac_ (_, form, id, result) => "Tac_ (thy," ^ form ^ "," ^ id ^ "," ^ result ^ ")"

  | _  => "tac_2str not impl. for arg";

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 = error (": not impl. for "^(tac_2str m));

end