(* Title:  Interpret/li-tool.sml

   Author: Walther Neuper 2000

   (c) due to copyright terms

Tools for Lucas_Interpreter

*)

signature LUCAS_INTERPRETER_TOOL =

sig

  datatype ass =

    Associated of Tactic.T * term (*..result*) * Proof.context

  | Ass_Weak of Tactic.T * term (*..result*) * Proof.context

  | Not_Associated;

  val associate: Ctree.ctree -> Proof.context -> (Tactic.T * term (*..Prog_Tac*)) -> ass

  val init_pstate: Rule_Set.T -> Proof.context -> I_Model.T -> MethodC.id ->

    Istate.T * Proof.context * Program.T

  val resume_prog: ThyC.id (*..for lookup in Know_Store*) -> Pos.pos' -> Ctree.ctree -> 

    (Istate.T * Proof.context) * Program.T

  val check_leaf: string -> Proof.context -> Rule_Set.T -> (Env.T * (term option * term)) -> term -> 

      Program.leaf * term option

  val implicit_take: Program.T -> (term * term) list -> term option

  val get_simplifier: Calc.T -> Rule_Set.T

  val tac_from_prog: Ctree.ctree -> theory (*..for lookup in Know_Store*) -> term -> Tactic.input

  val trace_on: bool Unsynchronized.ref

\<^isac_test>\<open>

  val arguments_from_model : MethodC.id -> I_Model.T -> term list

\<close>

end 

(**)

structure LItool(**): LUCAS_INTERPRETER_TOOL(**) =

struct

(**)

open Ctree

open Pos

(* traces the leaves (ie. non-tactical nodes) of Prog found by find_next_step *)   

val trace_on = Unsynchronized.ref false; (* TODO: adopt Isabelle's tracing *)

(* find the formal argument of a tactic in case there is only one (e.g. in simplification) *)

fun implicit_take (Rule.Prog prog) env =

    Option.map (subst_atomic env) (Prog_Tac.get_first_argument prog)

  | implicit_take _ _ = raise ERROR "implicit_take: no match";

(*  *)

val error_msg_1 = "ERROR: the guard is missing (#ppc in 'type met' added in prep_met)."

fun error_msg_2 d itms = ("arguments_from_model: '" ^ UnparseC.term d ^ "' not in itms:\n" ^

  "itms:\n" ^ I_Model.to_string @{context} itms)

(* turn Model-items into arguments for a program *)

fun arguments_from_model mI itms =

  let

    val mvat = I_Model.max_vt itms

    fun okv mvat (_, vats, b, _, _) = member op = vats mvat andalso b

    val itms = filter (okv mvat) itms

    fun test_dsc d (_, _, _, _, itm_) = (d = I_Model.d_in itm_)

    fun itm2arg itms (_,(d,_)) =

      case find_first (test_dsc d) itms of

        NONE => raise ERROR (error_msg_2 d itms)

      | SOME (_, _, _, _, itm_) => I_Model.penvval_in itm_

    val pats = (#ppc o MethodC.from_store) mI

    val _ = if pats = [] then raise ERROR error_msg_1 else ()

  in (flat o (map (itm2arg itms))) pats end;

(* convert a Prog_Tac to Tactic.input; specific for "Prog_Tac.SubProblem" *)

fun tac_from_prog _ thy (Const (\<^const_name>\<open>Prog_Tac.Rewrite\<close>, _) $ thmID $ _) =

    let

      val tid = HOLogic.dest_string thmID

    in (Tactic.Rewrite (tid, ThmC.thm_from_thy thy tid)) end

  | tac_from_prog _ thy (Const (\<^const_name>\<open>Prog_Tac.Rewrite_Inst\<close>, _) $ sub $ thmID $ _) =

    let

      val tid = HOLogic.dest_string thmID

    in (Tactic.Rewrite_Inst (Subst.program_to_input sub, (tid, ThmC.thm_from_thy thy tid))) end

  | tac_from_prog _ _ (Const (\<^const_name>\<open>Prog_Tac.Rewrite_Set\<close>,_) $ rls $ _) =

     (Tactic.Rewrite_Set (HOLogic.dest_string rls))

  | tac_from_prog _ _ (Const (\<^const_name>\<open>Prog_Tac.Rewrite_Set_Inst\<close>, _) $ sub $ rls $ _) =

      (Tactic.Rewrite_Set_Inst (Subst.program_to_input sub, HOLogic.dest_string rls))

  | tac_from_prog _ _ (Const (\<^const_name>\<open>Prog_Tac.Calculate\<close>, _) $ op_ $ _) =

      (Tactic.Calculate (HOLogic.dest_string op_))

  | tac_from_prog _ _ (Const (\<^const_name>\<open>Prog_Tac.Take\<close>, _) $ t) = (Tactic.Take (UnparseC.term t))

  | tac_from_prog _ _ (Const (\<^const_name>\<open>Prog_Tac.Substitute\<close>, _) $ isasub $ _) =

    (Tactic.Substitute ((Subst.eqs_to_input o TermC.isalist2list) isasub))

  | tac_from_prog _ thy (Const (\<^const_name>\<open>Prog_Tac.Check_elementwise\<close>, _) $ _ $ 

    (Const (\<^const_name>\<open>Collect\<close>, _) $ Abs (_, _, pred))) =

      (Tactic.Check_elementwise (UnparseC.term_in_thy thy pred))

  | tac_from_prog _ _ (Const (\<^const_name>\<open>Prog_Tac.Or_to_List\<close>, _) $ _ ) = Tactic.Or_to_List

  | tac_from_prog pt _ (ptac as Const (\<^const_name>\<open>Prog_Tac.SubProblem\<close>, _) $ _ $ _) =

    fst (Sub_Problem.tac_from_prog pt ptac) (*might involve problem refinement etc*)

  | tac_from_prog _ thy t = raise ERROR ("stac2tac_ TODO: no match for " ^ UnparseC.term_in_thy thy t);

datatype ass =

    Associated of

      Tactic.T         (* Subproblem' gets args instantiated in associate *)

      * term           (* resulting from application of Tactic.T          *)

      * Proof.context  (* updated by assumptioons from Rewrite*           *)

  | Ass_Weak of Tactic.T * term * Proof.context

  | Not_Associated;

(*

  associate is the ONLY code within by_tactic, which handles Tactic.T individually;

  thus it does ContextC.insert_assumptions in case of Rewrite*.

  The argument Ctree.ctree is required only for Subproblem'.

*)

fun trace_msg_3 tac =

  if (!trace_on) then

    tracing("@@@ the \"tac_\" proposed to apply does NOT match the leaf found in the program:\n" ^

      "@@@ tac_ = \"" ^ Tactic.string_of tac ^ "\"")

  else ();

fun associate _ ctxt (m as Tactic.Rewrite_Inst'

        (_, _, _, _, _, thm'' as (thmID, _), f, (f', asms')), stac) =

      (case stac of

  	    (Const (\<^const_name>\<open>Prog_Tac.Rewrite_Inst\<close>, _) $ _ $ thmID_ $ f_) =>

  	      if thmID = HOLogic.dest_string thmID_ then

  	        if f = f_ then 

              Associated (m, f', ContextC.insert_assumptions asms' ctxt)

  	        else Ass_Weak (m, f', ContextC.insert_assumptions asms' ctxt)

  	      else Not_Associated

      | (Const (\<^const_name>\<open>Prog_Tac.Rewrite_Set_Inst\<close>,_) $ _ $ rls_ $ f_) =>

  	      if Rule_Set.contains (Rule.Thm thm'') (assoc_rls (HOLogic.dest_string rls_)) then

            if f = f_ then

              Associated (m, f', ContextC.insert_assumptions asms' ctxt)

            else Ass_Weak (m, f', ContextC.insert_assumptions asms' ctxt)

  	      else Not_Associated

      | _ => Not_Associated)

  | associate _ ctxt (m as Tactic.Rewrite' (_, _, _, _, thm'' as (thmID, _), f, (f', asms')), stac) =

      (case stac of

  	    (Const (\<^const_name>\<open>Prog_Tac.Rewrite\<close>, _) $ thmID_ $ f_) =>

  	      if thmID = HOLogic.dest_string thmID_ then

  	        if f = f_ then

              Associated (m, f', ContextC.insert_assumptions asms' ctxt)

  	        else Ass_Weak (m, f', ContextC.insert_assumptions asms' ctxt)

  	      else Not_Associated

      | (Const (\<^const_name>\<open>Prog_Tac.Rewrite_Set\<close>, _) $ rls_ $ f_) =>

  	       if Rule_Set.contains (Rule.Thm thm'') (assoc_rls (HOLogic.dest_string rls_)) then

             if f = f_ then

               Associated (m, f', ContextC.insert_assumptions asms' ctxt)

  	         else Ass_Weak (m, f', ContextC.insert_assumptions asms' ctxt)

  	       else Not_Associated

      | _ => Not_Associated)

  | associate _ ctxt (m as Tactic.Rewrite_Set_Inst' (_, _, _, rls, f, (f', asms')),

        (Const (\<^const_name>\<open>Prog_Tac.Rewrite_Set_Inst\<close>, _) $ _ $ rls_ $ f_)) = 

      if Rule_Set.id rls = HOLogic.dest_string rls_ then

        if f = f_ then

          Associated (m, f', ContextC.insert_assumptions asms' ctxt)

        else Ass_Weak (m ,f', ContextC.insert_assumptions asms' ctxt)

      else Not_Associated

  | associate _ ctxt (m as Tactic.Rewrite_Set' (_, _, rls, f, (f', asms')),

        (Const (\<^const_name>\<open>Prog_Tac.Rewrite_Set\<close>, _) $ rls_ $ f_)) = 

      if Rule_Set.id rls = HOLogic.dest_string rls_ then

        if f = f_ then

          Associated (m, f', ContextC.insert_assumptions asms' ctxt)

        else Ass_Weak (m ,f', ContextC.insert_assumptions asms' ctxt)

      else Not_Associated

  | associate _ ctxt (m as Tactic.Calculate' (_, op_, f, (f', _)), stac) =

      (case stac of

  	    (Const (\<^const_name>\<open>Prog_Tac.Calculate\<close>,_) $ op__ $ f_) =>

  	      if op_ = HOLogic.dest_string op__ then

            if f = f_ then Associated (m, f', ctxt) else Ass_Weak (m ,f', ctxt)

  	      else Not_Associated

      | (Const (\<^const_name>\<open>Prog_Tac.Rewrite_Set_Inst\<close>, _) $ _ $ rls_ $ f_)  =>

          if Rule_Set.contains (Rule.Eval (assoc_calc' (ThyC.get_theory "Isac_Knowledge")

            op_ |> snd)) (assoc_rls (HOLogic.dest_string rls_)) then

            if f = f_ then Associated (m, f', ctxt) else Ass_Weak (m ,f', ctxt)

          else Not_Associated

      | (Const (\<^const_name>\<open>Prog_Tac.Rewrite_Set\<close>,_) $ rls_ $ f_) =>

          if Rule_Set.contains (Rule.Eval (assoc_calc' ( ThyC.get_theory "Isac_Knowledge")

            op_ |> snd)) (assoc_rls (HOLogic.dest_string rls_)) then

            if f = f_ then Associated (m, f', ctxt) else Ass_Weak (m ,f', ctxt)

          else Not_Associated

      | _ => Not_Associated)

  | associate _ ctxt (m as Tactic.Check_elementwise' (consts, _, (consts_chkd, _)),

        (Const (\<^const_name>\<open>Prog_Tac.Check_elementwise\<close>,_) $ consts' $ _)) =

      if consts = consts' then Associated (m, consts_chkd, ctxt) else Not_Associated

  | associate _ ctxt (m as Tactic.Or_to_List' (_, list), (Const (\<^const_name>\<open>Prog_Tac.Or_to_List\<close>, _) $ _)) =

      Associated (m, list, ctxt)

  | associate _ ctxt (m as Tactic.Take' term, (Const (\<^const_name>\<open>Prog_Tac.Take\<close>, _) $ _)) =

      Associated (m, term, ctxt)

  | associate _ ctxt (m as Tactic.Substitute' (ro, erls, subte, f, f'),

        (Const (\<^const_name>\<open>Prog_Tac.Substitute\<close>, _) $ _ $ t)) =

  	  if f = t then

  	   Associated (m, f', ctxt)

  	  else (*compare | applicable_in (p,p_) pt (m as Substitute sube)*)

  		  if foldl and_ (true, map TermC.contains_Var subte) then

  		    let

  		      val t' = subst_atomic (map HOLogic.dest_eq subte) t

  		    in

  		      if t = t' then raise ERROR "associate: Substitute' not applicable to val of Expr"

  		      else Associated (Tactic.Substitute' (ro, erls, subte, t, t'), t', ctxt)

  		    end

  		  else

  		    (case Rewrite.rewrite_terms_ (ThyC.Isac ()) ro erls subte t of

  		      SOME (t', _) =>  Associated (Tactic.Substitute' (ro, erls, subte, t, t'), t', ctxt)

  		    | NONE => raise ERROR "associate: Substitute' not applicable to val of Expr")

  | associate pt ctxt (Tactic.Subproblem' ((domID, pblID, _), _, _, _, _, _),

        (stac as Const (\<^const_name>\<open>Prog_Tac.SubProblem\<close>, _) $ _ $ _)) =

      (case Sub_Problem.tac_from_prog pt stac of

        (_, tac as Tactic.Subproblem' ((dI, pI, _), _, _, _, _, f)) =>

          if domID = dI andalso pblID = pI then Associated (tac, f, ctxt) else Not_Associated

      | _ => raise ERROR ("associate: uncovered case"))

  | associate _ _ (tac, _) = 

    (trace_msg_3 tac; Not_Associated);

(* create the initial interpreter state

  from the items of the guard and the formal arguments of the program.

Note on progression from (a) type fmz_ \<longrightarrow> (e) arguments of the partial_function:

  (a) fmz is given by a math author

  (b) fmz_ is transformed to ori list as a prerequisite for efficient interactive modelling

  (c) modelling creates an itm list from ori list + possible user input

  (d) specifying a theory might add some items and create a guard for the program

  (e) fun relate_args creates an environment for evaluating the program.

Note on sequence-relation (a) -- (e), i.e. the (formal) arguments of the program:

  * Since the arguments of the partial_function have no description (see Input_Descript.thy),

    (e) depends on the sequence in fmz_ and on the types of the formal arguments.

  * pairing formal arguments with itm's follows the sequence

  * Thus the resulting sequence-relation can be ambiguous.

  * Ambiguities are done by rearranging fmz_ or the formal arguments.

  * The latter is easier, albeit not optimal: a fmz_ can be used by different programs.

  *)

local

val errmsg = "ERROR: found no actual arguments for prog. of "

fun msg_miss sc metID caller f formals actuals =

  "ERROR in creating the environment from formal args. of partial_function \"" ^ fst (Program.get_fun_id sc) ^ "\"\n" ^

	"and the actual args., ie. items of the guard of \"" ^ MethodC.id_to_string metID ^ "\" by \"" ^ caller ^ "\":\n" ^

	"formal arg \"" ^ UnparseC.term f ^ "\" doesn't mach an actual arg.\n" ^

	"with:\n" ^

	(string_of_int o length) formals ^ " formal args: " ^ UnparseC.terms formals ^ "\n" ^

	(string_of_int o length) actuals ^ " actual args: " ^ UnparseC.terms actuals

fun msg_miss_type sc metID f formals actuals =

  "ERROR in creating the environment from formal args. of partial_function \"" ^ fst (Program.get_fun_id sc) ^ "\"\n" ^

	"and the actual args., ie. items of the guard of \"" ^ MethodC.id_to_string metID ^ "\" by \"assoc_by_type\":\n" ^

	"formal arg \"" ^ UnparseC.term f ^ "\" of type \"" ^ UnparseC.typ (type_of f) ^

  "\" doesn't mach an actual arg.\nwith:\n" ^

	(string_of_int o length) formals ^ " formal args: " ^ UnparseC.terms formals ^ "\n" ^

	(string_of_int o length) actuals ^ " actual args: " ^ UnparseC.terms actuals ^ "\n" ^

  "   with types: " ^ (strs2str o (map (UnparseC.typ o type_of))) actuals

fun msg_ambiguous sc metID f aas formals actuals =

  "AMBIGUITY in creating the environment from formal args. of partial_function \"" ^ fst (Program.get_fun_id sc) ^ "\"\n" ^

	"and the actual args., ie. items of the guard of \"" ^ MethodC.id_to_string metID ^ "\" by \"assoc_by_type\":\n" ^

  "formal arg. \"" ^ UnparseC.term f ^ "\" type-matches with several..."  ^

  "actual args. \"" ^ UnparseC.terms aas ^ "\"\n" ^

  "selected \"" ^ UnparseC.term (hd aas) ^ "\"\n" ^

	"with\n" ^

	"formals: " ^ UnparseC.terms formals ^ "\n" ^

	"actuals: " ^ UnparseC.terms actuals

fun trace_init metID =

  if (!trace_on) 

  then tracing("@@@ program \"" ^ strs2str metID ^ "\"")

  else ();

in

fun init_pstate srls ctxt itms metID =

  let

    val actuals = arguments_from_model metID itms

    val _ = if actuals <> [] then () else raise ERROR (errmsg ^ strs2str' metID)

    val (scr, sc) = (case (#scr o MethodC.from_store) metID of

           scr as Rule.Prog sc => (trace_init metID; (scr, sc))

       | _ => raise ERROR ("init_pstate with " ^ MethodC.id_to_string metID))

    val formals = Program.formal_args sc    

    fun assoc_by_type f aa =

      case filter (curry (fn (f, a) => type_of f = type_of a) f) aa of

        [] => raise ERROR (msg_miss_type sc metID f formals actuals)

      | [a] => (f, a)

      | aas as (a :: _) => (writeln (msg_ambiguous sc metID f aas formals actuals); (f, a));

	  fun relate_args _ (f::_)  [] = raise ERROR (msg_miss sc metID "relate_args" f formals actuals)

	    | relate_args env [] _ = env (*may drop Find?*)

	    | relate_args env (f::ff) (aas as (a::aa)) = 

	      if type_of f = type_of a 

	      then relate_args (env @ [(f, a)]) ff aa

        else

          let val (f, a) = assoc_by_type f aas

          in relate_args (env @ [(f, a)]) ff (remove op = a aas) end

    val {pre, prls, ...} = MethodC.from_store metID;

    val pres = Pre_Conds.check prls pre itms 0 |> snd |> map snd;

    val ctxt = ctxt |> ContextC.insert_assumptions pres;

    val ist = Istate.e_pstate

      |> Istate.set_eval srls

      |> Istate.set_env_true (relate_args [] formals actuals)

  in

    (Istate.Pstate ist, ctxt, scr)

  end;

end (*local*)

(* get the simplifier of the current method *)

fun get_simplifier (pt, (p, _)) =

  let

    val p' = Ctree.par_pblobj pt p

	  val metID = Ctree.get_obj Ctree.g_metID pt p'

	  val {srls, ...} = MethodC.from_store metID

  in srls end

(* resume program interpretation at the beginning of a step *)

fun resume_prog thy (p, p_) pt =

  let

    val (is_problem, p', rls') = parent_node pt p

  in

    if is_problem then

      let

	      val metID = get_obj g_metID pt p'

	      val {srls, ...} = MethodC.from_store metID

	      val (is, ctxt) =

	        case get_loc pt (p, p_) of

	           (Istate.Pstate ist, ctxt) => (Istate.Pstate (Istate.set_eval srls ist), ctxt)

	        | _ => raise ERROR "resume_prog: unexpected result from get_loc"

	    in

	      ((is, ctxt), (#scr o MethodC.from_store) metID)

	    end

    else

      (get_loc pt (p, p_),

      Rule.Prog (Auto_Prog.gen (ThyC.get_theory thy) (get_last_formula (pt, (p, p_))) rls'))

  end

fun trace_msg_1 call t stac =

  if (! trace_on) then

	  tracing ("@@@ " ^ call ^ " leaf \"" ^ UnparseC.term t ^ "\" \<longrightarrow> Tac \"" ^ UnparseC.term stac ^ "\"")

	else ();

fun trace_msg_2 call t lexpr' =

  if (! trace_on) then

	  tracing("@@@ " ^ call ^ " leaf '" ^ UnparseC.term t ^ "' \<longrightarrow> Expr \"" ^ UnparseC.term lexpr' ^ "\"")

	else ();

(*

  check a leaf at the end of recursive descent; a leaf is either a Prog_Tac or a Prog_Expr.

  snd of return value is the formal arguments in case of currying.

*)

fun check_leaf call ctxt srls (E, (a, v)) t =

    case Prog_Tac.eval_leaf E a v t of

	    (Program.Tac stac, a') =>

	      let

	        val stac' = Rewrite.eval_prog_expr (Proof_Context.theory_of ctxt) srls 

              (subst_atomic (Env.update_opt E (a, v)) stac)

	      in

          (trace_msg_1 call t stac; (Program.Tac stac', a'))

	      end

    | (Program.Expr lexpr, a') =>

	      let

	        val lexpr' = Rewrite.eval_prog_expr (Proof_Context.theory_of ctxt) srls

              (subst_atomic (Env.update_opt E (a, v)) lexpr)

	      in

          (trace_msg_2 call t lexpr'; (Program.Expr lexpr', a'))

	      end;

(**)end(**)