(* use this theory for tests before Build_Isac.thy has succeeded *)

theory Test_Theory imports "$ISABELLE_ISAC/Build_Isac"

begin                                                                            

ML_file "$ISABELLE_ISAC/BaseDefinitions/libraryC.sml"

section \<open>code for copy & paste ===============================================================\<close>

ML \<open>

\<close> ML \<open>

\<close> ML \<open>

"~~~~~ fun xxx , args:"; val () = ();

"~~~~~ and xxx , args:"; val () = ();

"~~~~~ from fun xxx \<longrightarrow>fun yyy \<longrightarrow>fun zzz , return:"; val () = ();

"~~~~~ continue fun xxx"; val () = ();

(*if*) (*then*); (*else*); (*andalso*)  (*case*) (*of*);  (*return value*); (*in*) (*end*);

"xx"

^ "xxx"   (*+*) (*+++*) (*keep for continuing YYYYY*) (*isa*) (*isa2*) (**)

\<close> ML \<open> (*//----------- build fun XXXXX -----------------------------------------------------\\*)

(*//------------------ build fun XXXXX -----------------------------------------------------\\*)

(*\\------------------ build fun XXXXX -----------------------------------------------------//*)

\<close> ML \<open> (*\\----------- build fun XXXXX -----------------------------------------------------//*)

val return_XXXXX = "XXXXX"

\<close> ML \<open> (*//----------- step into XXXXX -----------------------------------------------------\\*)

(*//------------------ step into XXXXX -----------------------------------------------------\\*)

\<close> ML \<open> (*||----------- contine XXXXX ---------------------------------------------------------*)

(*||------------------ contine XXXXX ---------------------------------------------------------*)

(*\\------------------ step into XXXXX -----------------------------------------------------//*)

\<close> ML \<open> (*\\----------- step into XXXXX -----------------------------------------------------//*)

val "XXXXX" = return_XXXXX;

(* final test ... ----------------------------------------------------------------------------*)

\<close> ML \<open> (*//----------- inserted hidden code ------------------------------------------------\\*)

(*//------------------ inserted hidden code ------------------------------------------------\\*)

(*\\------------------ inserted hidden code ------------------------------------------------//*)

\<close> ML \<open> (*\\----------- inserted hidden code ------------------------------------------------//*)

\<close>

ML \<open>

\<close> ML \<open>

\<close> ML \<open>

\<close>

text \<open>

  declare [[show_types]] 

  declare [[show_sorts]]

  find_theorems "?a <= ?a"

  print_theorems

  print_facts

  print_statement ""

  print_theory

  ML_command \<open>Pretty.writeln prt\<close>

  declare [[ML_print_depth = 999]]

  declare [[ML_exception_trace]]

\<close>

section \<open>===================================================================================\<close>

section \<open>=====  ============================================================================\<close>

ML \<open>

\<close> ML \<open>

\<close> ML \<open>

\<close>

section \<open>===================================================================================\<close>

section \<open>=====  ============================================================================\<close>

ML \<open>

\<close> ML \<open>

\<close> ML \<open>

\<close>

section \<open>===================================================================================\<close>

section \<open>=====maxi 150a-add-given-Maximum.sml ==============================================\<close>

ML \<open>

\<close> ML \<open>

(* Title:  "Minisubpbl/150a-add-given-Maximum.sml"

   Author: Walther Neuper 1105

   (c) copyright due to lincense terms.

ATTENTION: the file creates buffer overflow if copied in one piece !

Note: This test --- steps into me --- more than once, to a somewhat extreme extent;

  in order not to get lost while working in Test_Some etc, 

  re-introduce  ML (*--- step into XXXXX ---*) and Co.

  and use Sidekick for orientation.

  Nesting is indicated by  /---   //--   ///-  at the left margin of the comments.

*)

open Ctree;

open Pos;

open TermC;

open Istate;

open Tactic;

open Pre_Conds;

open I_Model;

open P_Model

open Rewrite;

open Step;

open LItool;

open LI;

open Test_Code

open Specify

open ME_Misc

val (_(*example text*),

  (model as ("Constants [r = (7::real)]" :: "Maximum A" :: "AdditionalValues [u, v]" :: 

     "Extremum (A = 2 * u * v - u \<up> 2)" :: 

     "SideConditions [((u::real) / 2) \<up> 2 + (2 / v) \<up> 2 = r \<up> 2]" :: 

     "SideConditions [((u::real) / 2) \<up> 2 + (2 / v) \<up> 2 = r \<up> 2]" :: 

     "SideConditions [(u::real) / 2 = r * sin \<alpha>, 2 / v = r * cos \<alpha>]" ::

(*---------------------------------------------,(v::real) / 2 = r * cos \<alpha>]" --- ERROR in example*)

     "FunctionVariable a" :: "FunctionVariable b" :: "FunctionVariable \<alpha>" :: 

     "Domain {0 <..< r}" :: "Domain {0 <..< r}" :: "Domain {0 <..< \<pi> / 2}" ::

     "ErrorBound (\<epsilon> = (0::real))" :: []), 

   refs as ("Diff_App", 

     ["univariate_calculus", "Optimisation"],

     ["Optimisation", "by_univariate_calculus"])))

  = Store.get (Know_Store.get_expls @{theory}) ["Diff_App-No.123a"] ["Diff_App-No.123a"];

\<close> ML \<open>

val c = [];

val return_init_calc = 

 Test_Code.init_calc @{context} [(model, refs)]; (*val Model_Problem = nxt;*)

\<close> ML \<open> (*/------------ step into init_calc -------------------------------------------------\\*)

(*/------------------- step into init_calc -------------------------------------------------\\*)

"~~~~~ fun init_calc , args:"; val (ctxt, [(model, refs as (thy_id, _, _))]) =

  (@{context}, [(model, refs)]);

\<close> ML \<open>

    val thy = thy_id |> ThyC.get_theory ctxt

\<close> ML \<open>

    val ((pt, p), tacis) = Step_Specify.initialise' thy (model, refs)

\<close> ML \<open>

	  val tac = case tacis of [] => Tactic.Empty_Tac | _ => (#1 o hd) tacis

\<close> ML \<open>

	  val f = 

           TESTg_form ctxt (pt,p);

\<close> ML \<open>

"~~~~~ fun TESTg_form , args:"; val (ctxt, ptp) = (ctxt, (pt,p));

\<close> ML \<open>

    val (form, _, _) =

   ME_Misc.pt_extract ctxt ptp

\<close> ML \<open>

"~~~~~ fun pt_extract , args:"; val (ctxt, (pt, (p, p_ as Pbl(*Frm,Pbl*)))) = (ctxt, ptp);

\<close> ML \<open>

        val ppobj = Ctree.get_obj I pt p

\<close> ML \<open>

        val f = if Ctree.is_pblobj ppobj then pt_model ppobj p_ else Ctree.get_obj pt_form pt p;

\<close> ML \<open>

            (*if*) Ctree.is_pblobj ppobj (*then*);

\<close> ML \<open>

           pt_model ppobj p_ ;

\<close> ML \<open> (*new...*)

"~~~~~ fun pt_model , args:"; val ((Ctree.PblObj {probl, spec, origin = (_, spec', hdl), ctxt, ...}), Pbl_) =

  (ppobj, p_);

\<close> ML \<open>

      val (_, pI, _) = Ctree.get_somespec' spec spec';

\<close> ML \<open>

(*    val where_ = if pI = Problem.id_empty then []*)

\<close> ML \<open>

               (*if*) pI = Problem.id_empty (*else*);

\<close> ML \<open>

	          val {where_rls, where_, model, ...} = Problem.from_store ctxt pI

\<close> ML \<open>

	          val (_, where_) = 

 Pre_Conds.check_OLD ctxt where_rls where_

              (model, I_Model.OLD_to_TEST probl);

\<close> ML \<open>

"~~~~~ fun check_OLD , args:"; val (ctxt, where_rls, pres, (model_patt, i_model)) =

  (ctxt, where_rls, where_, (model, I_Model.OLD_to_TEST probl));

\<close> ML \<open>

      val (_, (** )_( **)env_model(**), (env_subst, env_eval)) =

           of_max_variant model_patt i_model;

\<close> ML \<open>

(*maxi*)val "[]" = env_model |> Subst.to_string @{context}

(*maxi*)val "[]" = env_subst |> Subst.to_string @{context}

\<close> ML \<open>

"~~~~~ fun of_max_variant , args:"; val (_, []) = (model_patt, i_model);

(*\------------------- step into init_calc -------------------------------------------------//*)

\<close> ML \<open> (*\------------ step into init_calc -------------------------------------------------//*)

\<close> ML \<open>

val (p,_,f,nxt,_,pt) = return_init_calc;

\<close> ML \<open>

(*+*)val PblObj {ctxt, probl, ...} = get_obj I pt [];

(*+*)Proof_Context.theory_of ctxt (*= {Pure, .., Diff_App}*);

(*+*)val Free ("r", Type ("Real.real", [])) = Syntax.read_term ctxt "r"

(*+*)val [] = probl

\<close> ML \<open> (*ERROR penv_value: no values in 'Constants*)

val return_me_Model_Problem = 

           me nxt p c pt; val Add_Given "Constants [r = 7]" = #4 return_me_Model_Problem;

\<close> ML \<open> (*/------------ step into me Model_Problem ------------------------------------------\\*)

(*/------------------- step into me Model_Problem ------------------------------------------\\*)

"~~~~~ fun me , args:"; val (tac, (p:Pos.pos'), (_:Test_Code.NEW), (pt:Ctree.ctree)) = (nxt, p, c, pt);

      val ctxt = Ctree.get_ctxt pt p

val return_by_tactic = case

      Step.by_tactic tac (pt,p) of

		    ("ok", (_, _, ptp)) => ptp;

\<close> ML \<open> (*//----------- step into by_tactic -------------------------------------------------\\*)

(*//------------------ step into by_tactic -------------------------------------------------\\*)

"~~~~~ fun by_tactic , args:"; val (tac, (ptp as (pt, p))) = (tac, (pt,p));

val Applicable.Yes tac' = (*case*)

      Step.check tac (pt, p) (*of*);

(*+*)val Model_Problem' _ = tac';

"~~~~~ fun check , args:"; val (tac, (ctree, pos)) = (tac, (pt, p));

  (*if*) Tactic.for_specify tac (*then*);

Specify_Step.check tac (ctree, pos);

"~~~~~ fun check , args:"; val (Tactic.Model_Problem, (pt, pos as (p, _))) =

  (tac, (ctree, pos));

        val (o_model, pI', ctxt) = case Ctree.get_obj I pt p of

          Ctree.PblObj {origin = (o_model, (_, pI', _), _), ctxt, ...} => (o_model, pI', ctxt)

	      val {model = model_patt, ...} = Problem.from_store (Ctree.get_ctxt pt pos) pI'

	      val pbl = I_Model.init_TEST o_model model_patt;

val return_check =

    Applicable.Yes (Tactic.Model_Problem' (pI', I_Model.TEST_to_OLD pbl, []));

(*\\------------------ step into by_tactic -------------------------------------------------//*)

\<close> ML \<open> (*\\----------- step into by_tactic -------------------------------------------------//*)

val (pt, p) = return_by_tactic;

\<close> ML \<open>

val return_do_next = (*case*)

      Step.do_next p ((pt, Pos.e_pos'), []) (*of*);

\<close> ML \<open> (*//----------- step into do_next ---------------------------------------------------\\*)

(*//------------------ step into do_next ---------------------------------------------------\\*)

"~~~~~ fun do_next , args:"; val (((ip as (_,p_)):pos'), ((ptp as (pt,p), tacis):Calc.state_pre)) =

  (p, ((pt, e_pos'),[]));

\<close> ML \<open>

(*+*)val Pbl = p_

\<close> ML \<open>

    val pIopt = get_pblID (pt,ip);

    (*if*) ip = ([],Res); (* = false*)

      val _ = (*case*) tacis (*of*);

      val SOME _ = (*case*) pIopt (*of*);

\<close> ML \<open>

    val ("ok", ([(Add_Given "Constants [r = 7]", _, _)], [], _)) =

      Step.switch_specify_solve p_ (pt, ip);

\<close> ML \<open>

"~~~~~ fun switch_specify_solve , args:"; val (state_pos, (pt, input_pos)) = (p_, (pt, ip));

\<close> ML \<open>

      (*if*) Pos.on_specification ([], state_pos) (*then*);

\<close> ML \<open>

    val ("ok", ([(Add_Given "Constants [r = 7]", _, _)], [], _)) =

      Step.specify_do_next (pt, input_pos);

\<close> ML \<open> (*///---------- step into specify_do_next -------------------------------------------\\*)

(*///----------------- step into specify_do_next -------------------------------------------\\*)

"~~~~~ fun specify_do_next , args:"; val (ptp as (pt, (p, p_))) = (pt, input_pos);

\<close> ML \<open>

(*  val (_, (p_', tac)) =*)

val return_find_next_step = (*keep for continuing specify_do_next*)

   Specify.find_next_step ptp;

\<close> ML \<open> (*////--------- step into find_next_step --------------------------------------------\\*)

(*////---------------- step into find_next_step --------------------------------------------\\*)

"~~~~~ fun find_next_step , args:"; val ((pt, pos as (_, p_))) = (ptp);

    val {meth = met, origin = origin as (oris, o_refs as (_, pI', mI'), _), probl = pbl,

      spec = refs, ...} = Calc.specify_data (pt, pos);

    val ctxt = Ctree.get_ctxt pt pos;

      (*if*) Ctree.just_created (pt, pos) andalso origin <> Ctree.e_origin (*else*);

        (*if*) p_ = Pos.Pbl (*then*);

   Specify.for_problem ctxt oris (o_refs, refs) (pbl, met);

\<close> ML \<open> (*/////-------- step into for_problem -----------------------------------------------\\*)

(*/////--------------- step into for_problem -----------------------------------------------\\*)

"~~~~~ fun for_problem , args:"; val (ctxt, oris, ((dI', pI', mI'), (dI, pI, mI)), (pbl, met))

  = (ctxt, oris, (o_refs, refs), (pbl, met));

    val cdI = if dI = ThyC.id_empty then dI' else dI;

    val cpI = if pI = Problem.id_empty then pI' else pI;

    val cmI = if mI = MethodC.id_empty then mI' else mI;

    val {model = pbt, where_rls, where_, ...} = Problem.from_store ctxt cpI;

    val {model = mpc, ...} = MethodC.from_store ctxt cmI;

\<close> ML \<open> (*//----------- adhoc inserted fun check_OLD ----------------------------------------\\*)

(*//------------------ adhoc inserted fun check_OLD ----------------------------------------\\*)

(*T_TESTold* )

fun all_lhs_atoms ts = fold (curry and_) (map (fn t =>

  if can TermC.lhs t then TermC.is_atom (TermC.lhs t) else false) ts) true

( *T_TEST*)

fun all_lhs_atoms ts = fold (curry and_) (map (fn t =>

  if can TermC.lhs t andalso not (TermC.is_num (TermC.lhs t))

  then TermC.is_atom (TermC.lhs t)

  else false) ts) true

(*T_TESTnew*)

(*T_TESTold* )

fun handle_lists id (descr, ts) =

  if Model_Pattern.is_list_descr descr

  then if length ts > 1         (*list with more than 1 element needs to collect by [.., .., ..]*)

    then [(id, TermC.list2isalist (Model_Pattern.typ_of_element descr) ts)] (*AdditValues [u, v]*)

    else if TermC.is_atom (Library.the_single ts)

      then [(id, Library.the_single ts)]                                     (* solutions L, ...*)

      else [(id, TermC.list2isalist (Model_Pattern.typ_of_element descr) ts)](*Constants [r = 7]*)

  else [(id, Library.the_single ts)]                           (* solveFor x, Extremum (A = ...)*)

( *T_TEST***)

fun handle_lists id (descr, ts) =

  if Model_Pattern.is_list_descr descr

  then if length ts > 1         (*list with more than 1 element needs to collect by [.., .., ..]*)

    then if TermC.is_list (hd ts) (*---broken elementwise input to lists---*)

      then [(id, TermC.list2isalist (Model_Pattern.typ_of_element descr) (map TermC.the_single ts))]

      else [(id, TermC.list2isalist (Model_Pattern.typ_of_element descr) ts)] (*AdditValues [u, v]*)

    else if TermC.is_atom (Library.the_single ts)

      then [(id, Library.the_single ts)]                                     (* solutions L, ...*)

      else [(id, TermC.list2isalist (Model_Pattern.typ_of_element descr) ts)](*Constants [r = 7]*)

  else [(id, Library.the_single ts)]                           (* solveFor x, Extremum (A = ...)*)

(*T_TESTnew*)

;

handle_lists: term -> descriptor * term list -> (term * term) list;

fun mk_env_model _ (Model_Def.Cor_TEST ((_, []), _)) = []

  | mk_env_model id (Model_Def.Cor_TEST ((descr, ts), _)) = 

(*T_TEST.150* )

    if Model_Pattern.is_list_descr descr 

    then [(id, TermC.list2isalist (Model_Pattern.typ_of_element descr) ts)]

    else [(id, hd ts)]

( *T_TEST*)

    handle_lists id (descr, ts)

(*T_TEST.100*)

  | mk_env_model _ (Model_Def.Syn_TEST _) = [] (*TODO handle correct list elements*)

  | mk_env_model _ (Model_Def.Inc_TEST ((_, []), _)) = []

  | mk_env_model id (Model_Def.Inc_TEST ((descr, ts), _)) = 

(*T_TEST.150* )

    if Model_Pattern.is_list_descr descr 

    then [(id, TermC.list2isalist (Model_Pattern.typ_of_element descr) ts)]

    else [(id, hd ts)]

( *T_TEST*)

    handle_lists id (descr, ts)

(*T_TEST.100*)

  | mk_env_model _ (Model_Def.Sup_TEST _) = []

;

mk_env_model: term -> Model_Def.i_model_feedback_TEST -> Env.T;

val (id, (descr, ts)) = (@{term "v_v'i'::bool list"}, (@{term solutions}, [@{term "L::bool list"}]));

is_atom (Library.the_single [@{term "r = (7::real)"}]);

(*  vvvvvvvvvvvv-- REPLACES mk_env_subst_DEL, THUS THE LATTER IS UNCHANGED*)

fun make_env_model equal_descr_pairs =

  map (fn ((_, (_, id)), (_, _, _, _, (feedb, _)))

        => (mk_env_model id feedb)) equal_descr_pairs

  |> flat

;

make_env_model: (Model_Pattern.single * Model_Def.i_model_single_TEST) list -> Env.T;

fun switch_type_TEST descr [] = descr

  | switch_type_TEST (Free (id_string, _)) ts =

    Free (id_string, ts |> hd |> TermC.lhs |> type_of)

  | switch_type_TEST descr _ = raise ERROR ("switch_type_TEST undefined argument " ^

      quote (UnparseC.term (ContextC.for_ERROR ()) descr))

;

switch_type_TEST: descriptor -> term list -> descriptor;

(*T_TESTold* )

fun discern_typ _ (_, []) = []

  | discern_typ id (descr, ts) =

(*TODO.md "review (descriptor, ts)" REMOVE--------------------------------------\*)

    let

      val ts = if Model_Pattern.is_list_descr descr andalso TermC.is_list (hd ts)

        then TermC.isalist2list (hd ts)

        else ts

    in

(*TODO.md "review (descriptor, ts)" REMOVE--------------------------------------/*)

  if Model_Pattern.typ_of_element descr = HOLogic.boolT

    andalso ts |> map TermC.lhs |> all_atoms

  then

    if length ts > 1

    then raise ERROR "model items of type 'bool' in lists with 'lengt ts > 1' NOT YET IMPLEMENTED"

    else [((switch_type_TEST id ts, TermC.lhs (hd ts)), 

           (TermC.lhs (hd ts), TermC.rhs (hd ts)))]

  else []

(*TODO.md "review (descriptor, ts)" REMOVE--------------------------------------\*)

    end

(*TODO.md "review (descriptor, ts)" REMOVE--------------------------------------/*)

( *T_TEST*)

fun discern_typ _ (_, []) = []

  | discern_typ id (descr, ts) =

(*TODO.md "review (descriptor, ts)" REMOVE--------------------------------------\*)

    let

      val ts = if Model_Pattern.is_list_descr descr

        then if TermC.is_list (hd ts)

          then ts |> map TermC.isalist2list |> flat

          else ts

        else ts

    in

(*TODO.md "review (descriptor, ts)" REMOVE--------------------------------------/*)

  if Model_Pattern.typ_of_element descr = HOLogic.boolT andalso all_lhs_atoms ts

  then

    if length ts > 1

    then (writeln "model items of type 'bool' in lists with 'lengt ts > 1' NOT YET IMPLEMENTED";

      [])

    else [((switch_type_TEST id ts, TermC.lhs (hd ts)), 

           (TermC.lhs (hd ts), TermC.rhs (hd ts)))]

  else []

(*TODO.md "review (descriptor, ts)" REMOVE--------------------------------------\*)

    end

(*TODO.md "review (descriptor, ts)" REMOVE--------------------------------------/*)

;

discern_typ: term -> descriptor * term list -> ((term * term) * (term * term)) list;

(*T_TESTnew*)

fun discern_feedback id (Model_Def.Cor_TEST ((descr, ts), _)) = discern_typ id (descr, ts)

  | discern_feedback _ (Model_Def.Syn_TEST _) = [] (*TODO: handle correct elements*)

  | discern_feedback id (Model_Def.Inc_TEST ((descr, ts), _)) = discern_typ id (descr, ts)

  | discern_feedback _ (Model_Def.Sup_TEST _) = []

;

discern_feedback: term -> I_Model.feedback_TEST -> ((term * term) * (term * term)) list;

fun make_envs_preconds equal_givens =

  map (fn ((_, (_, id)), (_, _, _, _, (feedb, _))) => discern_feedback id feedb) equal_givens

  |> flat

;

make_envs_preconds: (Model_Pattern.single * I_Model.single_TEST) list ->

    ((term * term) * (term * term)) list;

(*T_TESTold* )

fun of_max_variant model_patt i_model =

( *T_TEST*)

fun of_max_variant _ [] = ([], [], ([], []))

  | of_max_variant model_patt i_model =

(*T_TESTnew*)

  let

    val all_variants =

        map (fn (_, variants, _, _, _) => variants) i_model

        |> flat

        |> distinct op =

    val variants_separated = map (filter_variants' i_model) all_variants

    val sums_corr = map (cnt_corrects) variants_separated

    val sum_variant_s = arrange_args1 sums_corr (1, all_variants)

    val (_, max_variant) = hd (*..crude decision, up to improvement *)

      (sort (fn ((i, _), (j, _)) => int_ord (i, j)) sum_variant_s)

    val i_model_max =

      filter (fn (_, variants, _ , _ ,_) => member (op =) variants max_variant) i_model

    val equal_descr_pairs = map (get_equal_descr i_model) model_patt |> flat

(*T_TESTold* )

    val env_subst = mk_env_subst_DEL equal_descr_pairs

    val env_eval = mk_env_eval_DEL i_model_max

  in

    (i_model_max, env_subst, env_eval)

  end

( *T_TEST*)

    val env_model = make_env_model equal_descr_pairs

    val equal_givens = filter (fn ((m_field, _), _) => m_field = "#Given") equal_descr_pairs

    val subst_eval_list = make_envs_preconds equal_givens

    val (env_subst, env_eval) = split_list subst_eval_list

  in

    (i_model_max, env_model, (env_subst, env_eval))

  end

(*T_TESTnew*)

;

of_max_variant: Model_Pattern.T -> Model_Def.i_model_TEST ->

       Model_Def.i_model_TEST * Env.T * (env_subst * env_eval);

fun check_OLD _ _ [] _  = (true, [])

  | check_OLD ctxt where_rls pres (model_patt, i_model) =

    let

(*T_TESTold* )

      val (env_subst, env_eval) = sep_variants_envs_OLD model_patt i_model

( *NEW*)  

      val (_, env_model, (env_subst, env_eval)) = of_max_variant model_patt i_model

(*NEW*)

      val pres_subst = map (TermC.subst_atomic_all env_subst) pres;

      val pres_subst_other = map (TermC.subst_atomic_all env_model) (map #2 pres_subst);

      val full_subst = if env_eval = [] then pres_subst_other

        else map (TermC.subst_atomic_all env_eval) (map #2 pres_subst_other)

      val evals = map (eval ctxt where_rls) full_subst

    in

      (foldl and_ (true, map fst evals), pres_subst_other)

    end

;

check_OLD: Proof.context -> Rule_Def.rule_set -> term list -> Model_Pattern.T * I_Model.T_TEST ->

  checked;

\<close> ML \<open>

\<close> ML \<open>

(*T_TESTold*)

fun check_from_store ctxt where_rls pres env_subst env_eval =

  let

    val pres_subst = map (TermC.subst_atomic_all env_subst) pres;

    val full_subst = map (fn (bool, t) => (bool, subst_atomic env_eval t)) pres_subst

    val evals = map (eval ctxt where_rls) full_subst

  in

    (foldl and_ (true, map fst evals), pres_subst)

  end

(*T_TEST*)

fun check_envs_TEST ctxt where_rls where_ (env_model, (env_subst, env_eval)) =

  let

      val pres_subst = map (TermC.subst_atomic_all env_subst) where_;

      val pres_subst_other = map (TermC.subst_atomic_all env_model) (map #2 pres_subst);

      val full_subst = if env_eval = [] then pres_subst_other

        else map (TermC.subst_atomic_all env_eval) (map #2 pres_subst_other)

      val evals = map (eval ctxt where_rls) full_subst

  in

      (foldl and_ (true, map fst evals), pres_subst_other)

  end

;

  check_envs_TEST: Proof.context -> Rule_Set.T -> unchecked -> Env.T * (env_subst * env_eval)

    -> checked

\<close> ML \<open>

(*T_TESTnew*)

\<close> ML \<open>

\<close> ML \<open>

(*\\------------------ adhoc inserted fun check_OLD ----------------------------------------//*)

\<close> ML \<open> (*\\----------- adhoc inserted fun check_OLD ----------------------------------------//*)

\<close> ML \<open> (*ERROR mk_env not reasonable for "Inc_TEST Constants [] [__=__, __=__]"*)

    val return_check_OLD =

           check_OLD ctxt where_rls where_ (pbt, I_Model.OLD_to_TEST pbl);

\<close> ML \<open> (*//////------- step into check_OLD -------------------------------------------------\\*)

(*//////-------------- step into check_OLD -------------------------------------------------\\*)

"~~~~~ fun check_OLD , args:"; val (ctxt, where_rls, pres, (model_patt, i_model)) =

  (ctxt, where_rls, where_, (pbt, I_Model.OLD_to_TEST pbl));

\<close> ML \<open>

      val return_of_max_variant =

           of_max_variant model_patt i_model;

\<close> ML \<open> (*///// //----- step into of_max_variant --------------------------------------------\\*)

(*///// //------------ step into of_max_variant --------------------------------------------\\*)

"~~~~~ fun of_max_variant , args:"; val (model_patt, i_model) =

  (model_patt, i_model);

(*with OLD code* )

(*+*)val "[\n(0, [], false ,#Given, (Inc_TEST Constants [__=__, __=__], Position.T)), \n(0, [], false ,#Find, (Inc_TEST Maximum __, Position.T)), \n(0, [], false ,#Find, (Inc_TEST AdditionalValues [__, __], Position.T)), \n(0, [], false ,#Relate, (Inc_TEST Extremum (__=__), Position.T)), \n(0, [], false ,#Relate, (Inc_TEST SideConditions [__=__, __=__], Position.T))]"

  = i_model |> I_Model.to_string_TEST @ {context}

( *with OLD code*)

\<close> ML \<open> (*with NEW code*)

(*+*)val "[\n(1, [1, 2, 3], false ,#Given, (Inc_TEST Constants [] [__=__, __=__], Position.T)), \n(2, [1, 2, 3], false ,#Find, (Inc_TEST Maximum __, Position.T)), \n(3, [1, 2, 3], false ,#Find, (Inc_TEST AdditionalValues [] [__, __], Position.T)), \n(4, [1, 2, 3], false ,#Relate, (Inc_TEST Extremum (__=__), Position.T)), \n(5, [1, 2], false ,#Relate, (Inc_TEST SideConditions [] [__=__, __=__], Position.T))]"

 = i_model |> I_Model.to_string_TEST @{context}

\<close> ML \<open>

    val all_variants =

        map (fn (_, variants, _, _, _) => variants) i_model

        |> flat

        |> distinct op =

    val variants_separated = map (filter_variants' i_model) all_variants

    val sums_corr = map (cnt_corrects) variants_separated

    val sum_variant_s = arrange_args1 sums_corr (1, all_variants)

\<close> ML \<open> (*with NEW code*)

(*+*)val [(0, 1), (0, 2), (0, 3)] = sum_variant_s

\<close> ML \<open>

    val (_, max_variant) = hd (*..crude decision, up to improvement *)

      (sort (fn ((i, _), (j, _)) => int_ord (i, j)) sum_variant_s)

    val i_model_max =

      filter (fn (_, variants, _ , _ ,_) => member (op =) variants max_variant) i_model

    val equal_descr_pairs = map (get_equal_descr i_model) model_patt |> flat

\<close> ML \<open>

(*for building make_env_s -------------------------------------------------------------------\*)

(*!!!*) val ("#Given", (descr, term), pos) =

  Model_Pattern.split_descriptor ctxt ("#Given", @{term "Constants [r = (7::real)]"}, Position.none)

(*!!!*) val patt = equal_descr_pairs |> hd |> #1

(*!!!*)val equal_descr_pairs =

  (patt,

  (1, [1, 2, 3], true, "#Given", (Cor_TEST ((descr, (*!*)TermC.isalist2list(*!*) term), 

                                                     (TermC.empty, [])), pos)))

  :: tl equal_descr_pairs

(*for building make_env_s -------------------------------------------------------------------/*)

\<close> ML \<open>

    val env_model = make_env_model equal_descr_pairs;

\<close> ML \<open> (*///// ///---- step into make_env_model --------------------------------------------\\*)

(*///// ///----------- step into make_env_model --------------------------------------------\\*)

"~~~~~ fun make_env_model , args:"; val (equal_descr_pairs) = (equal_descr_pairs);

val xxx = (fn ((_, (_, id)), (_, _, _, _, (feedb, _)))

       => (mk_env_model id feedb));

\<close> ML \<open>

val ((_, (_, id)), (_, _, _, _, (feedb, _))) = nth 4 equal_descr_pairs;

\<close> ML \<open> (*\\\\\ \\\---- step into make_env_model --------------------------------------------//*)

(*\\\\\ \\\----------- step into make_env_model --------------------------------------------//*)

\<close> ML \<open> (*||||| ||----- contine of_max_variant ------------------------------------------------*)

(*||||| ||------------ contine of_max_variant ------------------------------------------------*)

\<close> ML \<open> (*new on 15.7.*)

    val equal_givens = filter (fn ((m_field, _), _) => m_field = "#Given") equal_descr_pairs

\<close> ML \<open>

    val subst_eval_list = make_envs_preconds equal_givens

\<close> ML \<open>

val return_make_envs_preconds =

           make_envs_preconds equal_givens;

\<close> ML \<open> (*///// ///---- step into make_envs_preconds ----------------------------------------\\*)

(*///// ///----------- step into make_envs_preconds ----------------------------------------\\*)

"~~~~~ fun make_envs_preconds , args:"; val (equal_givens) = (equal_givens);

\<close> ML \<open>

val xxx = (fn ((_, (_, id)), (_, _, _, _, (feedb, _))) => discern_feedback id feedb)

;

xxx: (Model_Pattern.single * I_Model.single_TEST) -> ((term * term) * (term * term)) list;

\<close> ML \<open>

val return_discern_feedback =

           discern_feedback id feedb;

\<close> ML \<open>

(*nth 1 equal_descr_pairs* )

"~~~~~ fun discern_feedback , args:"; val (id, (Model_Def.Cor_TEST ((descr, ts), _))) = (id, feedb);

( *nth 2 equal_descr_pairs*)

"~~~~~ fun discern_feedback , args:"; val (id, (Model_Def.Inc_TEST ((descr, ts), _))) = (id, feedb);

(**)

\<close> ML \<open>

\<close> ML \<open>

\<close> ML \<open>

(*nth 1 equal_descr_pairs* )

(*+*)val [((Const ("fixes", typ1), Free ("r", typ2)),

           (Free ("r", typ3), value))] = return_discern_feedback

(*+*)val true = typ1 = typ2

(*+*)val true = typ3 = HOLogic.realT

(*+*)val "7" = UnparseC.term @{context} value

( *nth 2 equal_descr_pairs*)

\<close> ML \<open>

(*+*)val [] = return_discern_feedback

(**)

\<close> ML \<open>

val return_discern_typ =

           discern_typ id (descr, ts);

"~~~~~ fun discern_typ , args:"; val (id, (descr, ts)) = (id, (descr, ts));

\<close> ML \<open>

(*nth 1 equal_descr_pairs* )

(*+*)val [((Const ("fixes", typ1), Free ("r", typ2)),

           (Free ("r", typ3), value))] = return_discern_typ

(*+*)val true = typ1 = typ2

(*+*)val true = typ3 = HOLogic.realT

(*+*)val "7" = UnparseC.term @{context} value

( *nth 2 equal_descr_pairs*)

(*+*)val [] = return_discern_typ;

(**)

\<close> ML \<open>

           switch_type_TEST id ts;

\<close> ML \<open>

"~~~~~ fun switch_type_TEST , args:"; val (Const (descr_string, _), ts) = (descr, ts);

\<close> ML \<open>

\<close> ML \<open>

(*nth 1 equal_descr_pairs* )

val return_switch_type_TEST = Const (descr_string, ts |> hd |> TermC.lhs |> type_of)

(*+*)val Const ("Input_Descript.Constants", typ) = return_switch_type_TEST

(*+*)val Type ("Real.real", []) = typ

( *nth 2 equal_descr_pairs*)

(*+*)val return_switch_type_TEST = descr

(**)

\<close> ML \<open>

\<close> ML \<open>

\<close> ML \<open> (*\\\\\ \\\---- step into make_envs_preconds ----------------------------------------//*)

(*\\\\\ \\\----------- step into make_envs_preconds ----------------------------------------//*)

\<close> ML \<open> (*||||| ||----- contine of_max_variant ------------------------------------------------*)

(*||||| ||------------ contine of_max_variant ------------------------------------------------*)

    val subst_eval_list = make_envs_preconds equal_givens

\<close> ML \<open>

    val (env_subst, env_eval) = split_list subst_eval_list

\<close> ML \<open>

(*maxi*)val "[\"\n(fixes, [r = 7])\"]" = env_model |> Subst.to_string @{context}

(*maxi*)val "[\"\n(fixes, r)\"]" = env_subst |> Subst.to_string @{context}

\<close> ML \<open>

val return_of_max_variant = (i_model_max, env_model, (env_subst, env_eval)); (*GOON*)

(*\\\\\ \\------------ step into of_max_variant --------------------------------------------//*)

\<close> ML \<open> (*\\\\\ \\----- step into of_max_variant --------------------------------------------//*)

      val (i_model_max, env_model, (env_subst, env_eval)) = return_of_max_variant

\<close> ML \<open>

(*!!!/----- we had a helpful argument for constructing env_model and (env_subst, env_eval)---\*)

      val (i_max_variant, env_model, (env_subst, env_eval)) = (i_model_max, [], ([], []))

(*!!!\----- we had a helpful argument for constructing env_model and (env_subst, env_eval)---/*) 

\<close> ML \<open> (*||||||------- contine check_OLD -----------------------------------------------------*)

(*||||||-------------- contine check_OLD -----------------------------------------------------*)

\<close> ML \<open>

      val pres_subst = map (TermC.subst_atomic_all env_subst) pres;

      val pres_subst_other = map (TermC.subst_atomic_all env_model) (map #2 pres_subst);

      val full_subst = if env_eval = [] then pres_subst_other

        else map (TermC.subst_atomic_all env_eval) (map #2 pres_subst_other)

      val evals = map (eval ctxt where_rls) full_subst

val return_ = (i_model_max, env_subst, env_eval)

(*\\\\\\\------------- step into check_OLD -------------------------------------------------//*)

\<close> ML \<open> (*\\\\\\------- step into check_OLD -------------------------------------------------//*)

\<close> ML \<open>

val (preok, _) = return_check_OLD;

\<close> ML \<open> (*|||||-------- contine for_problem ---------------------------------------------------*)

(*|||||--------------- contine for_problem ---------------------------------------------------*)

    (*if*) dI' = ThyC.id_empty andalso dI = ThyC.id_empty (*else*);

      (*if*) pI' = Problem.id_empty andalso pI = Problem.id_empty (*else*);

val NONE =

     (*case*) find_first (I_Model.is_error o #5) pbl (*of*);

        (*case*)

   Specify.item_to_add (ThyC.get_theory ctxt

            (if dI = ThyC.id_empty then dI' else dI)) oris pbt pbl (*of*);

"~~~~~ fun item_to_add , args:"; val (thy, oris, _, itms)

  = ((ThyC.get_theory ctxt (if dI = ThyC.id_empty then dI' else dI)), oris, pbt, pbl);

      fun false_and_not_Sup (_, _, false, _, I_Model.Sup _) = false

        | false_and_not_Sup (_, _, false, _, _) = true

        | false_and_not_Sup _ = false

      val v = if itms = [] then 1 else Pre_Conds.max_variant itms

      val vors = if v = 0 then oris

        else filter ((fn variant =>

            fn (_, variants, m_field, _, _) => member op= variants variant andalso m_field <> "#undef")

          v) oris

(*+*)val "[\n(1, [\"1\", \"2\", \"3\"], #Given, Constants, [\"[r = 7]\"]), \n(2, [\"1\", \"2\", \"3\"], #Find, Maximum, [\"A\"]), \n(3, [\"1\", \"2\", \"3\"], #Find, AdditionalValues, [\"[u]\", \"[v]\"]), \n(4, [\"1\", \"2\", \"3\"], #Relate, Extremum, [\"A = 2 * u * v - u \<up> 2\"]), \n(5, [\"1\", \"2\"], #Relate, SideConditions, [\"[(u / 2) \<up> 2 + (2 / v) \<up> 2 = r \<up> 2]\"])]"

(*+*)  = vors |> O_Model.to_string @{context}

      val vits = if v = 0 then itms               (* because of dsc without dat *)

  	    else filter ((fn variant =>

            fn (_, variants, _, _, _) => member op= variants variant)

          v) itms;                                (* itms..vat *)

      val icl = filter false_and_not_Sup vits;    (* incomplete *)

      (*if*) icl = [] (*else*);

(*+*)val "[\n(1 ,[1, 2, 3] ,false ,#Given ,Inc Constants [] ,(Constants, [])), \n(2 ,[1, 2, 3] ,false ,#Find ,Inc Maximum ,(Maximum, [])), \n(3 ,[1, 2, 3] ,false ,#Find ,Inc AdditionalValues [] ,(AdditionalValues, [])), \n(4 ,[1, 2, 3] ,false ,#Relate ,Inc Extremum ,(Extremum, [])), \n(5 ,[1, 2] ,false ,#Relate ,Inc SideConditions [] ,(SideConditions, []))]"

(*+*)  = icl |> I_Model.to_string @{context}

(*+*)val "(1 ,[1, 2, 3] ,false ,#Given ,Inc Constants [] ,(Constants, []))"

(*+*)  = hd icl |> I_Model.single_to_string @{context}

(*++*)val feedback = (fn (_, _, _, _, feedback) => feedback) (hd icl)

(*++*)val Const ("Input_Descript.Constants", _) = I_Model.descriptor feedback

(*++*)val [] = I_Model.o_model_values feedback

(*+*)val "[\n(1, [\"1\", \"2\", \"3\"], #Given, Constants, [\"[r = 7]\"]), \n(2, [\"1\", \"2\", \"3\"], #Find, Maximum, [\"A\"]), \n(3, [\"1\", \"2\", \"3\"], #Find, AdditionalValues, [\"[u]\", \"[v]\"]), \n(4, [\"1\", \"2\", \"3\"], #Relate, Extremum, [\"A = 2 * u * v - u \<up> 2\"]), \n(5, [\"1\", \"2\"], #Relate, SideConditions, [\"[(u / 2) \<up> 2 + (2 / v) \<up> 2 = r \<up> 2]\"])]"

(*+*)  = vors |> O_Model.to_string @{context}

val SOME ori =

        (*case*) find_first ((fn (_, _, _, _, feedback) => fn (_, _, _, d, ts) =>

           d = I_Model.descriptor feedback andalso subset op = (I_Model.o_model_values feedback, ts))

         (hd icl)) vors (*of*);

(*+*)val "(1, [\"1\", \"2\", \"3\"], #Given, Constants, [\"[r = 7]\"])" =

(*+*)  ori |> O_Model.single_to_string @{context}

\<close> ML \<open> (*\\\\\-------- step into for_problem -----------------------------------------------//*)

(*\\\\\--------------- step into for_problem -----------------------------------------------//*)

\<close> ML \<open> (*\\\\--------- step into find_next_step --------------------------------------------//*)

(*\\\\---------------- step into find_next_step --------------------------------------------//*)

\<close> ML \<open> (*|||---------- continuing specify_do_next --------------------------------------------*)

(*|||----------------- continuing specify_do_next --------------------------------------------*)

\<close> ML \<open> (*while make Test_Theory work*)

val (_, (p_', tac)) = return_find_next_step (*kept for continuing specify_do_next*)

    val ist_ctxt =  Ctree.get_loc pt (p, p_)

(*+*)val Add_Given "Constants [r = 7]" = tac

val _ =

    (*case*) tac (*of*);

\<close> ML \<open>

Step_Specify.by_tactic_input tac (pt, (p, p_'));

\<close> ML \<open>

"~~~~~ fun by_tactic_input , args:"; val ((Tactic.Add_Given ct), ptp) =

  (tac, (pt, (p, p_')));

   Specify.by_Add_ "#Given" ct ptp;

"~~~~~ fun by_Add_ , args:"; val (m_field, ct ,(pt, pos as (_, p_))) =

  ("#Given", ct, ptp);

    val (met, oris, (_, pI', mI'), pbl, (_, pI, mI), ctxt) = SpecificationC.get_data (pt, pos)

    val (i_model, m_patt) =

       if p_ = Pos.Met then

         (met,

           (if mI = MethodC.id_empty then mI' else mI) |> MethodC.from_store ctxt |> #model)

       else

         (pbl,

           (if pI = Problem.id_empty then pI' else pI) |> Problem.from_store ctxt |> #model);

      (*case*)

   I_Model.check_single ctxt m_field oris i_model m_patt ct (*of*);

"~~~~~ fun check_single , args:"; val (ctxt, m_field, o_model, i_model, m_patt, (str(*, pos*))) =

  (ctxt, m_field, oris, i_model, m_patt, ct);

        val (t as (descriptor $ _)) = Syntax.read_term ctxt str

(*+*)val "Constants [r = 7]" = UnparseC.term @{context} t;

        val SOME m_field' =

          (*case*) Model_Pattern.get_field descriptor m_patt (*of*);

           (*if*) m_field <> m_field' (*else*);

(*+*)val "#Given" = m_field; val "#Given" = m_field'

val ("", ori', all) =

          (*case*) O_Model.contains ctxt m_field o_model t (*of*);

\<close> ML \<open>

(*+*)val (_, _, _, _, vals) = hd o_model;

\<close> ML \<open>

(*+*)val "Constants [r = 7]" = UnparseC.term @{context} (@{term Constants} $ (hd vals));

(*+*)if "[\n(1, [\"1\", \"2\", \"3\"], #Given, Constants, [\"[r = 7]\"]), " ^ 

(*+*)    "\n(2, [\"1\", \"2\", \"3\"], #Find, Maximum, [\"A\"]), " ^ 

(*+*)    "\n(3, [\"1\", \"2\", \"3\"], #Find, AdditionalValues, [\"[u]\", \"[v]\"]), " ^ 

(*+*)    "\n(4, [\"1\", \"2\", \"3\"], #Relate, Extremum, [\"A = 2 * u * v - u \<up> 2\"]), " ^ 

(*+*)    "\n(5, [\"1\", \"2\"], #Relate, SideConditions, [\"[(u / 2) \<up> 2 + (2 / v) \<up> 2 = r \<up> 2]\"]), " ^ 

(*+*)    "\n(6, [\"3\"], #Relate, SideConditions, [\"[u / 2 = r * sin \<alpha>]\", \"[2 / v = r * cos \<alpha>]\"]), " ^ 

(*+*)    "\n(7, [\"1\"], #undef, FunctionVariable, [\"a\"]), " ^ 

(*+*)    "\n(8, [\"2\"], #undef, FunctionVariable, [\"b\"]), \n(9, [\"3\"], #undef, FunctionVariable, [\"\<alpha>\"]), " ^ 

(*+*)    "\n(10, [\"1\", \"2\"], #undef, Input_Descript.Domain, [\"{0<..<r}\"]), " ^ 

(*+*)    "\n(11, [\"3\"], #undef, Input_Descript.Domain, [\"{0<..<\<pi> / 2}\"]), " ^ 

(*+*)    "\n(12, [\"1\", \"2\", \"3\"], #undef, ErrorBound, [\"\<epsilon> = 0\"])]"

(*+*)= O_Model.to_string @{context} o_model then () else error "o_model CHANGED";

\<close> ML \<open>

  (*case*) is_notyet_input ctxt i_model all ori' m_patt (*of*);

"~~~~~ fun is_notyet_input , args:"; val (ctxt, itms, all, (i, v, f, d, ts), pbt) =

  (ctxt, i_model, all, ori', m_patt);

val SOME (_, (_, pid)) =

  (*case*) find_first (eq1 d) pbt (*of*);

(*local*)fun eq3 f d (_, _, _, f', itm_) = f = f' andalso d = (I_Model.descriptor itm_);(*local*)

\<close> ML \<open>

val SOME (_, _, _, _, itm_) =

    (*case*) find_first (eq3 f d) itms (*of*);

val ts' = inter op = (o_model_values itm_) ts;

            (*if*) subset op = (ts, ts') (*else*);

val return_is_notyet_input = ("", 

           ori_2itm itm_ pid all (i, v, f, d, subtract op = ts' ts));

\<close> ML \<open>

"~~~~~ fun ori_2itm , args:"; val (itm_, pid, all, (id, vt, fd, d, ts)) =

  (itm_, pid, all, (i, v, f, d, subtract op = ts' ts));

\<close> ML \<open>

    val ts' = union op = (o_model_values itm_) ts;

    val pval = [Input_Descript.join'''' (d, ts')]

    val complete = if eq_set op = (ts', all) then true else false

(*+*)val "Inc Constants [] ,(Constants, [])" = itm_ |> I_Model.feedback_to_string @{context}

\<close> ML \<open> (*\\\---------- step into specify_do_next -------------------------------------------//*)

(*\\\----------------- step into specify_do_next -------------------------------------------//*)

\<close> ML \<open> (*\\----------- step into do_next ---------------------------------------------------//*)

(*\\------------------ step into do_next ---------------------------------------------------//*)

val ("ok", (ts as (_, _, _) :: _, _, (pt, p))) = return_do_next

\<close> ML \<open>

\<close> ML \<open>(*|------------- continue with me_Model_Problem ----------------------------------------*)

(*|------------------- continue with me_Model_Problem ----------------------------------------*)

\<close> ML \<open>

val tacis as (_::_) =

        (*case*) ts (*of*);

          val (tac, _, _) = last_elem tacis

\<close> ML \<open>

val return_Model_Problem = (p, [] : NEW, TESTg_form ctxt (pt, p), tac, Celem.Sundef, pt);

\<close> ML \<open>

\<close> ML \<open> (*//----------- step into TESTg_form ------------------------------------------------\\*)

(*//------------------ step into TESTg_form ------------------------------------------------\\*)

"~~~~~ fun TESTg_form , args:"; val (ctxt, ptp) = (ctxt, (pt, p));

\<close> ML \<open>

    val (form, _, _) =

   ME_Misc.pt_extract ctxt ptp;

\<close> ML \<open>

"~~~~~ fun pt_extract , args:"; val (ctxt, (pt, (p, p_(*Frm,Pbl*)))) = (ctxt, ptp);

\<close> ML \<open>

        val ppobj = Ctree.get_obj I pt p

\<close> ML \<open>

        val f = if Ctree.is_pblobj ppobj then pt_model ppobj p_ else Ctree.get_obj pt_form pt p;

\<close> ML \<open>

          (*if*) Ctree.is_pblobj ppobj (*then*);

\<close> ML \<open>

           pt_model ppobj p_;

\<close> ML \<open>

"~~~~~ fun pt_model , args:"; val ((Ctree.PblObj {probl, spec, origin = (_, spec', hdl), ctxt, ...}), 

  Pbl(*Frm,Pbl*)) = (ppobj, p_);

\<close> ML \<open>

      val (_, pI, _) = Ctree.get_somespec' spec spec';

\<close> ML \<open>

                 (*if*) pI = Problem.id_empty (*else*); 

(*    val where_ = if pI = Problem.id_empty then []*)

(*      else                                       *)

(*        let                                      *)

	          val {where_rls, where_, model, ...} = Problem.from_store ctxt pI

\<close> ML \<open>

	          val (_, where_) = (*Pre_Conds.*)check_OLD ctxt where_rls where_ (model, I_Model.OLD_to_TEST probl)

(*        in where_ end                           *)

\<close> ML \<open>  (*ERROR from previous*)

	    val allcorrect = I_Model.is_complete probl andalso foldl and_ (true, (map #1 where_))

\<close> ML \<open>

val return_pt_model = Ctree.ModSpec (allcorrect, Pos.Pbl, hdl, probl, where_, spec)

\<close> ML \<open>

\<close> ML \<open>(*|------------- continue with TESTg_form ----------------------------------------------*)

(*|------------------- continue with TESTg_form ----------------------------------------------*)

\<close> ML \<open> (*while make Test_Theory work*)

val Ctree.ModSpec (spec as (_, p_, _, gfr, where_, _)) =

    (*case*) form (*of*);

    Test_Out.PpcKF (  (Test_Out.Problem [],

 			P_Model.from (Proof_Context.theory_of ctxt) gfr where_));

   P_Model.from (Proof_Context.theory_of ctxt) gfr where_;

"~~~~~ fun from , args:"; val (thy, itms, where_) = ((Proof_Context.theory_of ctxt), gfr, where_);

    fun coll model [] = model

      | coll model ((_, _, _, field, itm_) :: itms) =

        coll (add_sel_ppc thy field model (item_from_feedback thy itm_)) itms;

 val gfr = coll P_Model.empty itms;

"~~~~~ fun coll , args:"; val (model, ((aaa, bbb_,ccc_, field, itm_) :: itms))

  = (P_Model.empty, itms);

(*+*)val 4 = length itms;

(*+*)val itm = nth 1 itms;

           coll P_Model.empty [itm];

"~~~~~ fun coll , iterate:"; val (model, ((aaa, bbb_,ccc_, field, itm_) :: []))

  = (P_Model.empty, [itm]);

          (add_sel_ppc thy field model (item_from_feedback thy itm_));

"~~~~~ fun add_sel_ppc , args:"; val ((_: theory), sel, {Given = gi, Where = wh, Find = fi, With = wi, Relate = re}, x )

  = (thy, field, model, (item_from_feedback thy itm_));

   P_Model.item_from_feedback thy itm_;

"~~~~~ fun item_from_feedback , args:"; val (thy, (I_Model.Inc ((d, ts), _))) = (thy, itm_);

   P_Model.Incompl (UnparseC.term_in_thy thy (Input_Descript.join (d, ts)));

(*\\------------------ step into TESTg_form ------------------------------------------------//*)

\<close> ML \<open> (*\\----------- step into TESTg_form ------------------------------------------------//*)

\<close> ML \<open> (*\------------ step into me Model_Problem ------------------------------------------//*)

(*\------------------- step into me Model_Problem ------------------------------------------//*)

\<close> ML \<open> (*while make Test_Theory work*)

val (p, _, f, nxt, _, pt) = return_me_Model_Problem

\<close> ML \<open> (*------------- contine me's ----------------------------------------------------------*)

(*-------------------- contine me's ----------------------------------------------------------*)

val return_me_add_find_Constants = me nxt p c pt;

                                      val Add_Find "Maximum A" = #4 return_me_add_find_Constants;

\<close> ML \<open> (*/------------ step into me_add_find_Constants -------------------------------------\\*)

(*/------------------- step into me_add_find_Constants -------------------------------------\\*)

"~~~~~ fun me , args:"; val (tac as Add_Given "Constants [r = 7]", p, _(*NEW remove*), pt) =

  (nxt, p, c, pt);

\<close> ML \<open>

      val ctxt = Ctree.get_ctxt pt p

\<close> ML \<open>

(*+*)val PblObj {probl = (1, [1, 2, 3], false, "#Given", Inc 

    ((Const ("Input_Descript.Constants", _), []), _)) :: _, ...}  = get_obj I pt (fst p)

(*-------------------------------------------^^--*)

val return_step_by_tactic = (*case*) 

      Step.by_tactic tac (pt, p) (*of*);

\<close> ML \<open> (*//----------- step into Step.by_tactic --------------------------------------------\\*)

(*//------------------ step into Step.by_tactic --------------------------------------------\\*)

"~~~~~ fun by_tactic , args:"; val (tac, (ptp as (pt, p))) = (tac, (pt, p));

\<close> ML \<open>

val Applicable.Yes tac' =

    (*case*) check tac (pt, p) (*of*);

\<close> ML \<open>

	    (*if*) Tactic.for_specify' tac' (*then*);

\<close> ML \<open>

Step_Specify.by_tactic tac' ptp;

\<close> ML \<open>

"~~~~~ fun by_tactic , args:"; val ((Tactic.Add_Given' (ct, _)), (pt, p)) = (tac', ptp);

\<close> ML \<open>

   Specify.by_Add_ "#Given" ct (pt, p);

\<close> ML \<open>

"~~~~~ fun by_Add_ , args:"; val (m_field, ct, (pt, pos as (_, p_))) = ("#Given", ct, (pt, p));

\<close> ML \<open>

    val (met, oris, (_, pI', mI'), pbl, (_, pI, mI), ctxt) = SpecificationC.get_data (pt, pos);

\<close> ML \<open>

(*  val (i_model, m_patt) =*)

       (*if*) p_ = Pos.Met (*else*);

\<close> ML \<open>

val return_by_Add_ =

         (pbl,

           (if pI = Problem.id_empty then pI' else pI) |> Problem.from_store ctxt |> #model)

\<close> ML \<open>

val I_Model.Add i_single =

      (*case*) I_Model.check_single ctxt m_field oris i_model m_patt ct (*of*);

\<close> ML \<open>

\<close> ML \<open>

	          val i_model' =

   I_Model.add_single (Proof_Context.theory_of ctxt) i_single i_model;

\<close> ML \<open>

"~~~~~ fun add_single , args:"; val (thy, itm, model) =

  ((Proof_Context.theory_of ctxt), i_single, i_model);

\<close> ML \<open>

    fun eq_untouched d (0, _, _, _, itm_) = (d = I_Model.descriptor itm_)

      | eq_untouched _ _ = false

\<close> ML \<open>

    val model' = case I_Model.seek_ppc (#1 itm) model of

      SOME _ => overwrite_ppc thy itm model (*itm updated in is_notyet_input WN.11.03*)

\<close> ML \<open>

\<close> ML \<open>

\<close> ML \<open>

\<close> ML \<open> (*||----------- contine Step.by_tactic ------------------------------------------------*)

(*||------------------ contine Step.by_tactic ------------------------------------------------*)

(*\\------------------ step into Step.by_tactic --------------------------------------------//*)

\<close> ML \<open> (*\\----------- step into Step.by_tactic --------------------------------------------//*)

val ("ok", (_, _, ptp)) = return_step_by_tactic;

\<close> ML \<open>

      val (pt, p) = ptp;

\<close> ML \<open>

        (*case*) 

      Step.do_next p ((pt, Pos.e_pos'), []) (*of*);

\<close> ML \<open>

"~~~~~ fun do_next , args:"; val ((ip as (_, p_)), (ptp as (pt, p), tacis)) =

  (p, ((pt, Pos.e_pos'), []));

\<close> ML \<open>

  (*if*) Pos.on_calc_end ip (*else*);

\<close> ML \<open>

      val (_, probl_id, _) = Calc.references (pt, p);

\<close> ML \<open>

val _ =

      (*case*) tacis (*of*);

\<close> ML \<open>

        (*if*) probl_id = Problem.id_empty (*else*);

\<close> ML \<open>

           switch_specify_solve p_ (pt, ip);

\<close> ML \<open>

"~~~~~ fun switch_specify_solve , args:"; val (state_pos, (pt, input_pos)) = (p_, (pt, ip));

\<close> ML \<open>

      (*if*) Pos.on_specification ([], state_pos) (*then*);

\<close> ML \<open>