1 (* Title: "Interpret/lucas-interpreter.sml"
3 (c) due to copyright terms
6 "-----------------------------------------------------------------------------------------------";
7 "table of contents -----------------------------------------------------------------------------";
8 "-----------------------------------------------------------------------------------------------";
9 "----------- Take as 1st stac in program -------------------------------------------------------";
10 "----------- re-build: fun locate_input_tactic -------------------------------------------------";
11 "----------- fun locate_input_tactic Helpless, but applicable ----------------------------------";
12 "----------- re-build: fun find_next_step, mini ------------------------------------------------";
13 "----------- re-build: fun locate_input_term ---------------------------------------------------";
14 "-----------------------------------------------------------------------------------------------";
15 "-----------------------------------------------------------------------------------------------";
16 "-----------------------------------------------------------------------------------------------";
18 "----------- Take as 1st stac in program -------------------------------------------------------";
19 "----------- Take as 1st stac in program -------------------------------------------------------";
20 "----------- Take as 1st stac in program -------------------------------------------------------";
21 "compare --- Apply_Method with initial Take by Step.do_next --- in test/../step-solve ----------";
22 val p = e_pos'; val c = [];
23 val (p,_,f,nxt,_,pt) =
25 [(["functionTerm (x^^^2 + 1)", "integrateBy x", "antiDerivative FF"],
26 ("Integrate", ["integrate","function"], ["diff","integration"]))];
27 val (p,_,f,nxt,_,pt) = me nxt p c pt; (*nxt = ("Tac ", ...) --> Add_Given...*)
28 val (p,_,f,nxt,_,pt) = me nxt p c pt;
29 val (p,_,f,nxt,_,pt) = me nxt p c pt;
30 val (p,_,f,nxt,_,pt) = me nxt p c pt;
31 val (p,_,f,nxt,_,pt) = me nxt p c pt;
32 val (p,_,f,nxt,_,pt) = me nxt p c pt;
33 val (p,_,f,nxt,_,pt) = me nxt p c pt;
34 case nxt of (Apply_Method ["diff", "integration"]) => ()
35 | _ => error "integrate.sml -- me method [diff,integration] -- spec";
36 "----- step 8: returns nxt = Rewrite_Set_Inst ([\"(''bdv'', x)\"],\"integration\")";
38 "~~~~~ fun me, args:"; val (tac, (p:pos'), _, (pt:ctree)) = (nxt, p, c, pt);
39 "~~~~~ fun Step.by_tactic, args:"; val (tac, (ptp as (pt, p))) = (tac, (pt,p));
40 val Appl m = applicable_in p pt tac;
41 (*if*) Tactic.for_specify' m; (*false*)
42 "~~~~~ fun loc_solve_ , args:"; val (m, (pt,pos)) = (m, ptp);
44 "~~~~~ fun Step_Solve.by_tactic , args:"; val (m as Apply_Method' (mI, _, _, ctxt), (pt, (pos as (p,_))))
46 val {srls, ...} = get_met mI;
47 val itms = case get_obj I pt p of
48 PblObj {meth=itms, ...} => itms
49 | _ => error "solve Apply_Method: uncovered case get_obj"
50 val thy' = get_obj g_domID pt p;
51 val thy = Celem.assoc_thy thy';
52 val srls = LItool.get_simplifier (pt, pos)
53 val (is, env, ctxt, sc) = case LItool.init_pstate srls ctxt itms mI of
54 (is as Istate.Pstate {env, ...}, ctxt, sc) => (is, env, ctxt, sc)
55 | _ => error "solve Apply_Method: uncovered case init_pstate";
56 (*+*)pstate2str (the_pstate is) = "([\"\n(f_f, x ^^^ 2 + 1)\",\"\n(v_v, x)\"], [], e_rls, NONE, \n??.empty, ORundef, false, true)";
57 val ini = LItool.init_form thy sc env;
60 val NONE = (*case*) ini (*of*);
61 val Next_Step (is', ctxt', m') =
62 LI.find_next_step sc (pt, (p, Res)) is ctxt;
63 (*+*)pstate2str (the_pstate is') = "([\"\n(f_f, x ^^^ 2 + 1)\",\"\n(v_v, x)\"], [R,L,R], e_rls, NONE, \nIntegral x ^^^ 2 + 1 D x, ORundef, false, false)";
64 val Safe_Step (_, _, Take' _) = (*case*)
65 locate_input_tactic sc (pt, (p, Res)) is' ctxt' m' (*of*);
66 "~~~~~ fun locate_input_tactic , args:"; val ((Prog prog), cstate, istate, ctxt, tac)
67 = (sc, (pt, (p, Res)), is', ctxt', m');
69 (*case*) scan_to_tactic1 (prog, (cstate, ctxt, tac)) istate (*of*);
70 "~~~~~ fun scan_to_tactic1 , args:"; val ((prog, (cctt as ((_, p), _, _))), (Istate.Pstate (ist as {path, ...})))
71 = ((prog, (cstate, ctxt, tac)), istate);
72 (*if*) path = [] orelse ((last_elem o fst) p = 0 andalso snd p = Res) (*then*);
74 val Accept_Tac1 (_, _, Take' _) =
75 scan_dn1 cctt (ist |> set_path [R] |> set_or ORundef) (Program.body_of prog);
76 "~~~~~ fun scan_dn1 , args:"; val (xxx, ist, (Const ("HOL.Let", _) $ e $ (Abs (id, T, b))))
77 = (cctt, (ist |> set_path [R] |> set_or ORundef), (Program.body_of prog));
79 (*+*) if term2str e = "Take (Integral f_f D v_v)" then () else error "scan_dn1 Integral changed";
82 scan_dn1 xxx (ist |> path_down [L, R]) e (*of*);
83 (*======= end of scanning tacticals, a leaf =======*)
84 "~~~~~ fun scan_dn1 , args:"; val (((pt, p), ctxt, tac), (ist as {eval, or, ...}), t)
85 = (xxx, (ist |> path_down [L, R]), e);
86 val (Program.Tac stac, a') = check_leaf "locate" ctxt eval (get_subst ist) t;
90 "----------- re-build: fun locate_input_tactic -------------------------------------------------";
91 "----------- re-build: fun locate_input_tactic -------------------------------------------------";
92 "----------- re-build: fun locate_input_tactic -------------------------------------------------";
93 val fmz = ["equality (x+1=(2::real))", "solveFor x","solutions L"];
94 val (dI',pI',mI') = ("Test", ["sqroot-test","univariate","equation","test"],
95 ["Test","squ-equ-test-subpbl1"]);
96 val (p,_,f,nxt,_,pt) = CalcTreeTEST [(fmz, (dI',pI',mI'))];
97 val (p,_,f,nxt,_,pt) = me nxt p [] pt;
98 val (p,_,f,nxt,_,pt) = me nxt p [] pt;
99 val (p,_,f,nxt,_,pt) = me nxt p [] pt;
100 val (p,_,f,nxt,_,pt) = me nxt p [] pt;
101 val (p,_,f,nxt,_,pt) = me nxt p [] pt;
102 val (p,_,f,nxt,_,pt) = me nxt p [] pt;
103 (*[], Met*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = (_, Apply_Method ["Test", "squ-equ-test-subpbl1"])*);
104 (*[1], Frm*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = ("Rewrite_Set", Rewrite_Set "norm_equation")*)
106 (*//------------------ begin step into ------------------------------------------------------\\*)
107 (*[1], Res*)val (p'''''_''',_,f,nxt'''''_''',_,pt'''''_''') = me nxt p [] pt; (*nxt = Rewrite_Set "Test_simplify"*)
109 "~~~~~ fun me , args:"; val (tac, p, _(*NEW remove*), pt) = (nxt, p, [], pt);
111 (** )val (***)xxxx(***) ( *("ok", (_, _, (pt, p))) =( **) (*case*)
112 Step.by_tactic tac (pt,p) (*of*);
113 "~~~~~ fun by_tactic , args:"; val (tac, (ptp as (pt, p))) = (tac, (pt,p));
114 val Applicable.Appl m = (*case*) Applicable.applicable_in p pt tac (*of*);
115 (*if*) Tactic.for_specify' m; (*false*)
117 (** )val (***)xxxxx_x(***) ( *(msg, cs') =( **)
118 Step_Solve.by_tactic m ptp;
119 "~~~~~ fun by_tactic , args:"; val (m, (pt, po as (p, p_))) = (m, ptp);
120 (*+*)val (pt'''''_', (p'''''_', p_'''''_')) = (pt, (p, p_));
121 (*if*) Celem.e_metID = get_obj g_metID pt (par_pblobj pt p); (*else*)
122 val thy' = get_obj g_domID pt (par_pblobj pt p);
123 val (is, sc) = LItool.resume_prog thy' (p,p_) pt;
125 locate_input_tactic sc (pt, po) (fst is) (snd is) m;
126 "~~~~~ fun locate_input_tactic , args:"; val (Prog prog, cstate, istate, ctxt, tac)
127 = (sc, (pt, po), (fst is), (snd is), m);
128 val srls = get_simplifier cstate;
130 (** )val Accept_Tac1 ((is as (_,_,_,_,_,strong_ass), ctxt, ss as((tac', _, ctree, pos', _) :: _))) =( **)
131 (*case*) scan_to_tactic1 (prog, (cstate, ctxt, tac)) istate (*of*);
132 "~~~~~ fun scan_to_tactic1 , args:"; val ((prog, (cctt as ((_, p), _, _))), (Istate.Pstate (ist as {path, ...})))
133 = ((prog, (cstate, ctxt, tac)), istate);
134 (*if*) path = [] orelse ((last_elem o fst) p = 0 andalso snd p = Res) (*then*);
136 (** )val xxxxx_xx = ( **)
137 scan_dn1 cctt (ist |> set_path [R] |> set_or ORundef) (Program.body_of prog);
138 "~~~~~ fun scan_dn1 , args:"; val (xxx, ist, (Const ("HOL.Let", _) $ e $ (Abs (id, T, b))))
139 = (cctt, (ist |> set_path [R] |> set_or ORundef), (Program.body_of prog));
141 (*case*) scan_dn1 xxx (ist |> path_down [L, R]) e (*of*);
142 "~~~~~ fun scan_dn1 , args:"; val ((xxx as (cstate, _, _)), ist, (Const ("Tactical.Chain"(*1*), _) $ e1 $ e2 $ a))
143 = (xxx, (ist |> path_down [L, R]), e);
145 (*case*) scan_dn1 xxx (ist |> path_down_form ([L, L, R], a)) e1 (*of*);
146 "~~~~~ fun scan_dn1 , args:"; val (xxx, ist, (Const ("Tactical.Try"(*2*), _) $ e))
147 = (xxx, (ist |> path_down_form ([L, L, R], a)), e1);
149 (*case*) scan_dn1 xxx (ist |> path_down [R]) e (*of*);
150 (*======= end of scanning tacticals, a leaf =======*)
151 "~~~~~ fun scan_dn1 , args:"; val (((pt, p), ctxt, tac), (ist as {env, eval, or, ...}), t)
152 = (xxx, (ist |> path_down [R]), e);
153 val (Program.Tac stac, a') =
154 (*case*) check_leaf "locate" ctxt eval (get_subst ist) t (*of*);
155 val LItool.Ass (m, v', ctxt) =
156 (*case*) associate pt ctxt (m, stac) (*of*);
158 Accept_Tac1 (ist |> set_subst_true (a', v'), ctxt, m) (*return value*);
159 "~~~~~ from scan_dn1 to scan_to_tactic1 return val:"; val (xxxxx_xx)
160 = (Accept_Tac1 (ist |> set_subst_true (a', v'), ctxt, m));
162 "~~~~~ from scan_to_tactic1 to fun locate_input_tactic return val:"; val Accept_Tac1 ((ist as {assoc, ...}), ctxt, tac')
163 = (Accept_Tac1 (ist |> set_subst_true (a', v'), ctxt, m));
164 (*if*) LibraryC.assoc (*then*);
166 Safe_Step (Istate.Pstate ist, ctxt, tac') (*return value*);
167 "~~~~~ from locate_input_tactic to fun Step_Solve.by_tactic return:"; val Safe_Step (istate, ctxt, tac)
168 = (*xxxxx_xx*)(**)Safe_Step (Istate.Pstate ist, ctxt, tac')(**);
170 (*+*)val (pt, po as (p, p_)) = (pt'''''_', (p'''''_', p_'''''_')); (* from begin of by_tactic *)
171 val (p'', _, _,pt') =
172 Generate.generate1 tac (istate, ctxt) (pt, (lev_on p, Pbl));
175 ("ok", ([(Tactic.input_from_T tac, tac, (p'', (istate, ctxt)))],
176 [(*ctree NOT cut*)], (pt', p''))) (*return value*);
177 "~~~~~ from Step_Solve.by_tactic \<longrightarrow> Step.by_tactic return:"; val ((msg, cs' : calcstate'))
178 = ("ok", ([(Tactic.input_from_T tac, tac, (p'', (istate, ctxt)) )],
179 [(*ctree NOT cut*)], (pt', p'')));
181 "~~~~~ from Step.by_tactic to me return:"; val (("ok", (_, _, (pt, p)))) = (*** )xxxx( ***) ("ok", cs');
183 (case Step.do_next p ((pt, Pos.e_pos'), []) of
184 ("ok", (ts as (_, _, _) :: _, _, _)) => ("", ts)
185 | ("helpless", _) => ("helpless: cannot propose tac", [])
186 | ("no-fmz-spec", _) => error "no-fmz-spec"
187 | ("end-of-calculation", (ts, _, _)) => ("", ts)
188 | _ => error "me: uncovered case")
189 handle ERROR msg => raise ERROR msg
192 tacis as (_::_) => let val (tac, _, _) = last_elem tacis in tac end
193 | _ => if p = ([], Pos.Res) then Tactic.End_Proof' else Tactic.Empty_Tac;
195 (p, [] : NEW, TESTg_form (pt, p), (Tactic.tac2IDstr tac, tac), Telem.Sundef, pt);
196 "~~~~~ from me to TOOPLEVEL return:"; val (p,_,f,nxt,_,pt)
197 = (*** )xxx( ***) (p, [] : NEW, TESTg_form (pt, p), (Tactic.tac2IDstr tac, tac), Telem.Sundef, pt);
199 (*//--------------------- check results from modified me ----------------------------------\\*)
200 if p = ([2], Res) andalso
201 pr_ctree pr_short pt = ". ----- pblobj -----\n1. x + 1 = 2\n2. x + 1 = 2\n"
203 (case nxt of ("Rewrite_Set", Rewrite_Set "Test_simplify") => ()
205 else error "check results from modified me CHANGED";
206 (*\\--------------------- check results from modified me ----------------------------------//*)
208 "~~~~~ from me to TOPLEVEL return:"; val (p,_,f,nxt,_,pt) = (*** )xxx( ***) (**)(p, 000, f, nxt, 000, pt)(**);
209 (*\\------------------ end step into --------------------------------------------------------//*)
211 (*[3], Res*)val (p,_,f,nxt,_,pt) = me nxt'''''_''' p'''''_''' [] pt'''''_'''; (*nxt = Subproblem ("Test", ["LINEAR", "univariate", "equation", "test"])*)
212 (*[3], Pbl*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = Model_Problem*)
213 (*[3], Pbl*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = Add_Given "equality (-1 + x = 0)"*)
214 (*[3], Pbl*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = Add_Given "solveFor x"*)
215 (*[3], Pbl*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = Add_Find "solutions x_i"*)
216 (*[3], Pbl*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = Specify_Theory "Test"*)
217 (*[3], Pbl*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = Specify_Problem ["LINEAR", "univariate", "equation", "test"]*)
218 (*[3], Pbl*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = Specify_Method ["Test", "solve_linear"]*)
219 (*[3], Met*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = Apply_Method ["Test", "solve_linear"]*)
220 (*[3, 1], Frm*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = Rewrite_Set_Inst (["(''bdv'', x)"], "isolate_bdv")*)
221 (*[3, 1], Res*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = Rewrite_Set "Test_simplify"*)
222 (*[3, 2], Res*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = Check_Postcond ["LINEAR", "univariate", "equation", "test"]*)
223 (*[3], Res*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = Check_elementwise "Assumptions"*)
224 (*[4], Res*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = Check_Postcond ["sqroot-test", "univariate", "equation", "test"]*)
225 (*[], Res*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = End_Proof'*)
227 (*/--------------------- final test ----------------------------------\\*)
228 if p = ([], Res) andalso f2str f = "[x = 1]" andalso pr_ctree pr_short pt =
229 ". ----- pblobj -----\n" ^
231 "2. x + 1 + -1 * 2 = 0\n" ^
232 "3. ----- pblobj -----\n" ^
233 "3.1. -1 + x = 0\n" ^
234 "3.2. x = 0 + -1 * -1\n" ^
236 then case nxt of End_Proof' => () | _ => error "re-build: fun locate_input_tactic changed 1"
237 else error "re-build: fun locate_input_tactic changed 2";
240 "----------- fun locate_input_tactic Helpless, but applicable ----------------------------------";
241 "----------- fun locate_input_tactic Helpless, but applicable ----------------------------------";
242 "----------- fun locate_input_tactic Helpless, but applicable ----------------------------------";
243 (*cp from -- try fun applyTactics ------- *)
244 val (p,_,f,nxt,_,pt) = CalcTreeTEST [(["Term (5*e + 6*f - 8*g - 9 - 7*e - 4*f + 10*g + 12)",
246 ("PolyMinus",["plus_minus","polynom","vereinfachen"],
247 ["simplification","for_polynomials","with_minus"]))];
248 val (p,_,f,nxt,_,pt) = me nxt p [] pt; val (p,_,f,nxt,_,pt) = me nxt p [] pt;
249 val (p,_,f,nxt,_,pt) = me nxt p [] pt; val (p,_,f,nxt,_,pt) = me nxt p [] pt;
250 val (p,_,f,nxt,_,pt) = me nxt p [] pt; val (p,_,f,nxt,_,pt) = me nxt p [] pt;
251 (*[1], Frm*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = Rewrite_Set "ordne_alphabetisch"*)
252 (*[1], Res*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = Rewrite_Set "fasse_zusammen"*)
254 (*+*)if map tac2str (specific_from_prog pt p) =
255 ["Rewrite (\"subtrahiere_x_plus_minus\", \"\<lbrakk>?l is_const; ?m is_const\<rbrakk>\n\<Longrightarrow> ?x + ?m * ?v - ?l * ?v = ?x + (?m - ?l) * ?v\")",
256 "Rewrite (\"subtrahiere_x_minus_plus\", \"\<lbrakk>?l is_const; ?m is_const\<rbrakk>\n\<Longrightarrow> ?x - ?m * ?v + ?l * ?v = ?x + (- ?m + ?l) * ?v\")"]
257 then () else error "specific_from_prog ([1], Res) CHANGED";
258 (*[2], Res*)val ("ok", (_, _, ptp as (pt, p))) = Step.by_tactic (hd (specific_from_prog pt p)) (pt, p);
260 (*+*)if map tac2str (specific_from_prog pt p) =
261 ["Rewrite (\"tausche_minus\", \"\<lbrakk>?b ist_monom; ?a kleiner ?b\<rbrakk>\n\<Longrightarrow> ?b - ?a = - ?a + ?b\")", "Rewrite (\"tausche_plus_minus\", \"?b kleiner ?c \<Longrightarrow> ?a + ?c - ?b = ?a - ?b + ?c\")",
262 "Rewrite (\"subtrahiere_x_plus_minus\", \"\<lbrakk>?l is_const; ?m is_const\<rbrakk>\n\<Longrightarrow> ?x + ?m * ?v - ?l * ?v = ?x + (?m - ?l) * ?v\")",
263 "Rewrite (\"subtrahiere_x_minus_plus\", \"\<lbrakk>?l is_const; ?m is_const\<rbrakk>\n\<Longrightarrow> ?x - ?m * ?v + ?l * ?v = ?x + (- ?m + ?l) * ?v\")", "Calculate MINUS"]
264 then () else error "specific_from_prog ([1], Res) CHANGED";
265 (* = ([3], Res)*)val ("ok", (_, _, ptp as (pt, p))) = Step.by_tactic (hd (specific_from_prog pt p)) (pt, p);
267 (*//----------------- exception PTREE "get_obj f EmptyPtree" raised --------------------------\\*)
268 (** )val ("ok", (_, _, ptp as (pt, p))) =( **) Step.by_tactic (hd (specific_from_prog pt p)) (pt, p);
269 "~~~~~ fun Step.by_tactic , args:"; val (tac, (ptp as (pt, p))) = (hd (specific_from_prog pt p), (pt, p));
270 val Applicable.Appl m = (*case*) Applicable.applicable_in p pt tac (*of*);
271 (*if*) Tactic.for_specify' m; (*false*)
273 Step_Solve.by_tactic m (pt, p);
274 "~~~~~ fun by_tactic , args:"; val (m, (pt, po as (p, p_))) = (m, (pt, p));
275 (*if*) Celem.e_metID = get_obj g_metID pt (par_pblobj pt p) (*else*);
276 val thy' = get_obj g_domID pt (par_pblobj pt p);
277 val (is, sc) = LItool.resume_prog thy' (p,p_) pt;
279 (*case*) locate_input_tactic sc (pt, po) (fst is) (snd is) m (*of*);
280 "~~~~~ fun locate_input_tactic , args:"; val ((Rule.Prog prog), (cstate as (pt, (*?*)pos(*?*))), istate, ctxt, tac)
281 = (sc, (pt, po), (fst is), (snd is), m);
282 val srls = LItool.get_simplifier cstate (*TODO: shift into Istate.T*);
284 (*case*) scan_to_tactic1 (prog, (cstate, ctxt, tac)) istate (*of*);
285 "~~~~~ fun scan_to_tactic1 , args:"; val ((prog, (cctt as ((_, p), _, _))), (Istate.Pstate (ist as {path, ...})))
286 = ((prog, (cstate, ctxt, tac)), istate);
287 (*if*) path = [] orelse ((last_elem o fst) p = 0 andalso snd p = Res) (*else*);
289 go_scan_up1 (prog, cctt) ist;
290 "~~~~~ and go_scan_up1 , args:"; val ((yyy as (prog, _)), (ist as {path, ...}))
291 = ((prog, cctt), ist);
292 (*if*) 1 < length path (*then*);
294 scan_up1 yyy (ist |> path_up) (at_location (path_up' path) prog);
295 "~~~~~ fun scan_up1 , args:"; val (yyy, ist, (Const ("Tactical.Try"(*2*), _) $ _))
296 = (yyy, (ist |> path_up), (at_location (path_up' path) prog));
299 "~~~~~ and go_scan_up1 , args:"; val ((yyy as (prog, _)), (ist as {path, ...}))
301 (*if*) 1 < length path (*then*);
303 scan_up1 yyy (ist |> path_up) (at_location (path_up' path) prog);
304 "~~~~~ fun scan_up1 , args:"; val ((yyy as (prog, xxx as (cstate, _, _))), ist,
305 (Const ("Tactical.Chain"(*3*), _) $ _ ))
306 = (yyy, (ist |> path_up), (at_location (path_up' path) prog));
307 val e2 = check_Seq_up ist prog
309 (*case*) scan_dn1 xxx (ist |> path_up_down [R] |> set_or ORundef) e (*of*);
310 "~~~~~ fun scan_dn1 , args:"; val (yyy, ist, (Const ("Tactical.Chain"(*2*), _) $ _ $ _))
311 = (xxx, (ist |> path_up_down [R] |> set_or ORundef), e2);
313 (*case*) scan_dn1 xxx (ist |> path_down [L, R]) e1 (*of*);
314 "~~~~~ fun scan_dn1 , args:"; val (xxx, ist, (Const ("Tactical.Try"(*2*), _) $ e))
315 = (xxx, (ist |> path_down [L, R]), e1);
317 (*case*) scan_dn1 xxx (ist |> path_down [R]) e (*of*);
318 (*======= end of scanning tacticals, a leaf =======*)
319 "~~~~~ fun scan_dn1 , args:"; val (((pt, p), ctxt, tac), (ist as {eval, act_arg, or, ...}), t)
320 = (xxx, (ist |> path_down [R]), e);
321 val (Program.Tac stac, a') = (*case*) check_leaf "locate" ctxt eval (get_subst ist) t (*of*);
322 val NotAss = (*case*) associate pt ctxt (tac, stac) (*of*);
323 val ORundef = (*case*) or (*of*);
324 val Notappl "norm_equation not applicable" =
325 (*case*) Applicable.applicable_in p pt (LItool.tac_from_prog pt (Celem.assoc_thy "Isac_Knowledge") stac) (*of*);
327 (Term_Val1 act_arg) (* return value *);
329 val Rewrite' ("PolyMinus", "tless_true", _, _, ("tausche_minus",_ (*"?b ist_monom \<Longrightarrow> ?a kleiner ?b \<Longrightarrow> ?b - ?a = - ?a + ?b"*)),
333 "([\"\n(t_t, 5 * e + 6 * f - 8 * g - 9 - 7 * e - 4 * f + 10 * g + 12)\"], [R,L,R,R,L,R,R], e_rls, SOME t_t, \n" ^
334 "- (8 * g) + (- 9 + 12 + 5 * e - 7 * e + (6 - 4) * f) + 10 * g, ORundef, true, false)"
336 term2str t = "- (8 * g) + (- 9 + 12 + 5 * e - 7 * e + (6 - 4) * f) + 10 * g"
338 term2str res = "- (8 * g) + (- 9 + 12 + 5 * e - 7 * e + (- 4 + 6) * f) + 10 * g"
340 terms2str asm = "[\"4 kleiner 6\",\"6 ist_monom\"]"
341 then () else error "locate_input_tactic Helpless, but applicable CHANGED";
344 "----------- re-build: fun find_next_step, mini ------------------------------------------------";
345 "----------- re-build: fun find_next_step, mini ------------------------------------------------";
346 "----------- re-build: fun find_next_step, mini ------------------------------------------------";
347 val fmz = ["Term (a + a ::real)", "normalform n_n"];
348 val (dI',pI',mI') = ("Poly",["polynomial","simplification"],["simplification","for_polynomials"]);
349 val (p,_,f,nxt,_,pt) = CalcTreeTEST [(fmz, (dI',pI',mI'))];
350 (*[], Pbl*)val (_, ([(tac, _, _)], _, (pt, p))) = Step.do_next p ((pt, Pos.e_pos'), []);(*Model_Problem*)
351 (*[], Pbl*)val (_, ([(tac, _, _)], _, (pt, p))) = Step.do_next p ((pt, Pos.e_pos'), []);(*Specify_Theory "Poly"*)
352 (*[], Pbl*)val (_, ([(tac, _, _)], _, (pt, p))) = Step.do_next p ((pt, Pos.e_pos'), []);(*Specify_Problem ["polynomial", "simplification"]*)
353 (*[], Met*)val (_, ([(tac, _, _)], _, (pt, p))) = Step.do_next p ((pt, e_pos'), []);(*Specify_Method ["simplification", "for_polynomials"]*)
354 (*1], Frm*)val (_, ([(tac, _, _)], _, (pt, p))) = Step.do_next p ((pt, e_pos'), []);(*Apply_Method ["simplification", "for_polynomials"]*)
355 (*[1], Res*)val (_, ([(tac'''''_', _, _)], _, (pt'''''_', p'''''_'))) =
357 Step.do_next p ((pt, e_pos'), []);(*Rewrite_Set "norm_Poly"*)
358 (*//------------------ go into 1 ------------------------------------------------------------\\*)
359 "~~~~~ fun do_next , args:"; val ((ip as (_, p_)), (ptp as (pt, p), tacis))
360 = (p, ((pt, e_pos'), []));
361 val pIopt = Ctree.get_pblID (pt, ip);
362 (*if*) ip = ([], Res) (*else*);
363 val _ = (*case*) tacis (*of*);
364 val SOME _ = (*case*) pIopt (*of*);
365 (*if*) member op = [Pos.Pbl, Pos.Met] p_
366 andalso is_none (Ctree.get_obj Ctree.g_env pt (fst p)) (*else*);
368 val ("ok", ([(Rewrite_Set "norm_Poly", _, _)], _, (_, ([1], Res)))) =
369 Step_Solve.do_next (pt, ip);
370 "~~~~~ and do_next , args:"; val (ptp as (pt, pos as (p, p_))) = (pt, ip);
371 (*if*) Celem.e_metID = get_obj g_metID pt (par_pblobj pt p) (*else*);
372 val thy' = get_obj g_domID pt (par_pblobj pt p);
373 val ((ist, ctxt), sc) = LItool.resume_prog thy' (p,p_) pt;
375 val Next_Step (_, _, Rewrite_Set' ("Poly", _, Seq {id = "norm_Poly", ...}, _, _)) =
376 LI.find_next_step sc (pt, pos) ist ctxt (*of*);
377 "~~~~~ fun find_next_step , args:"; val ((Rule.Prog prog), (ptp as(pt, (p, _))), (Pstate ist), ctxt)
378 = (sc, (pt, pos), ist, ctxt);
380 val Accept_Tac (Rewrite_Set' ("Poly", _, Seq {id = "norm_Poly", ...}, _, _), _, _) =
381 (*case*) scan_to_tactic (prog, (ptp, ctxt)) (Pstate ist) (*of*);
382 "~~~~~ fun scan_to_tactic , args:"; val ((prog, cc), (Pstate (ist as {path, ...})))
383 = ((prog, (ptp, ctxt)), (Pstate ist));
384 (*if*) path = [] (*then*);
386 val Accept_Tac (Rewrite_Set' ("Poly", _, Seq {id = "norm_Poly", ...}, _, _), _, _) =
387 scan_dn cc (trans_scan_dn ist) (Program.body_of prog);
388 "~~~~~ fun scan_dn , args:"; val ((cc as (_, ctxt)), (ist as {eval, ...}), t)
389 = (cc, (trans_scan_dn ist), (Program.body_of prog));
390 (*if*) Tactical.contained_in t (*else*);
391 val (Program.Tac prog_tac, form_arg) = (*case*) LItool.check_leaf "next " ctxt eval (get_subst ist) t (*of*);
393 val Accept_Tac (Rewrite_Set' ("Poly", _, Seq {id = "norm_Poly", ...}, _, _), _, _) =
394 check_tac cc ist (prog_tac, form_arg) (*return from xxx*);
395 "~~~~~ from fun scan_dn\<longrightarrow>fun scan_to_tactic\<longrightarrow>fun find_next_step, return:"; val (Accept_Tac (tac, ist, ctxt))
396 = (check_tac cc ist (prog_tac, form_arg));
398 Next_Step (Pstate ist, Tactic.insert_assumptions tac ctxt, tac) (*return from find_next_step*);
399 "~~~~~ from fun find_next_step\<longrightarrow>and do_next\<longrightarrow>fun zzz, return:"; val (Next_Step (ist, ctxt, tac))
400 = (Next_Step (Pstate ist, Tactic.insert_assumptions tac ctxt, tac));
402 LI.by_tactic tac (ist, Tactic.insert_assumptions tac ctxt) ptp (*return from and do_next*);
403 "~~~~~ from and do_next\<longrightarrow>fun do_next\<longrightarrow>toplevel, return:"; val (_, ([(tac''''', _, _)], _, (pt''''', p''''')))
404 = (LI.by_tactic tac (ist, Tactic.insert_assumptions tac ctxt) ptp);
405 (*\\------------------ end of go into 1 -----------------------------------------------------//*)
407 (*[], Res*)val (_, ([(tac''''', _, _)], _, (pt''''', p'''''))) =
409 Step.do_next p'''''_' ((pt'''''_', Pos.e_pos'), []);(* Check_Postcond ["polynomial", "simplification"]*)
410 (*//------------------ go into 2 ------------------------------------------------------------\\*)
411 "~~~~~ fun do_next , args:"; val ((ip as (_, p_)), (ptp as (pt, p), tacis))
412 = (p''''', ((pt''''', e_pos'), []));
413 val pIopt = Ctree.get_pblID (pt, ip);
414 (*if*) ip = ([], Res) (*else*);
415 val _ = (*case*) tacis (*of*);
416 val SOME _ = (*case*) pIopt (*of*);
417 (*if*) member op = [Pos.Pbl, Pos.Met] p_
418 andalso is_none (Ctree.get_obj Ctree.g_env pt (fst p)) (*else*);
420 val ("ok", ([(Check_Postcond ["polynomial", "simplification"], _, _)], _, (_, ([], Res)))) =
421 Step_Solve.do_next (pt, ip);
422 "~~~~~ and do_next , args:"; val (ptp as (pt, pos as (p, p_))) = (pt, ip);
423 (*if*) Celem.e_metID = get_obj g_metID pt (par_pblobj pt p) (*else*);
424 val thy' = get_obj g_domID pt (par_pblobj pt p);
425 val ((ist, ctxt), sc) = LItool.resume_prog thy' (p,p_) pt;
427 (** )val End_Program (ist, tac) =
428 ( *case*) LI.find_next_step sc (pt, pos) ist ctxt (*of*);
429 "~~~~~ fun find_next_step , args:"; val ((Rule.Prog prog), (ptp as(pt, (p, _))), (Pstate ist), ctxt)
430 = (sc, (pt, pos), ist, ctxt);
432 (* val Term_Val (Const ("Groups.times_class.times", _) $ Free ("2", _) $ Free ("a", _))*)
433 (** )val Term_Val prog_result =
434 ( *case*) scan_to_tactic (prog, (ptp, ctxt)) (Pstate ist) (*of*);
435 "~~~~~ fun scan_to_tactic , args:"; val ((prog, cc), (Pstate (ist as {path, ...})))
436 = ((prog, (ptp, ctxt)), (Pstate ist));
437 (*if*) path = [] (*else*);
439 go_scan_up (prog, cc) (trans_scan_up ist |> set_found);
440 "~~~~~ fun go_scan_up , args:"; val ((pcc as (sc, _)), (ist as {path, act_arg, found_accept, ...}))
441 = ((prog, cc), (trans_scan_up ist(*|> set_found !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! *)));
442 (*if*) path = [R] (*then*);
443 (*if*) found_accept = true (*then*);
445 Term_Val act_arg (*return from go_scan_up*);
446 "~~~~~ from fun go_scan_up\<longrightarrow>fun scan_to_tactic, return:"; val (Term_Val prog_result) = (Term_Val act_arg);
448 Term_Val prog_result (*return from scan_to_tactic*);
449 "~~~~~ from fun scan_to_tactic\<longrightarrow>fun find_next_step, return:"; val (Term_Val prog_result) = (Term_Val prog_result);
450 val (true, p', _) = (*case*) parent_node pt p (*of*);
451 val (_, pblID, _) = get_obj g_spec pt p';
453 End_Program (Pstate ist, Tactic.Check_Postcond' (pblID, (prog_result, [])))
454 (*return from find_next_step*);
455 "~~~~~ from fun find_next_step\<longrightarrow>and do_next\<longrightarrow>fun zzz, return:"; val (End_Program (ist, tac))
456 = (End_Program (Pstate ist, Tactic.Check_Postcond' (pblID, (prog_result, []))));
457 val _ = (*case*) tac (*of*);
459 val ("ok", ([(Check_Postcond ["polynomial", "simplification"], _, _)], _, (_, ([], Res))))
460 = LI.by_tactic tac (ist, ctxt) ptp (*return from and do_next*);
461 "~~~~~ from and do_next\<longrightarrow>top level, return:"; val (_, ([(tac''''', _, _)], _, (pt''''', p''''')))
462 = (LI.by_tactic tac (ist, ctxt) ptp);
463 (*\\------------------ end of go into 2 -----------------------------------------------------//*)
465 (*[], Und*)val (msg, ([], _, (pt, p))) = Step.do_next p''''' ((pt''''', Pos.e_pos'), []);(**)
468 ([], Frm), Simplify (a + a)
469 . . . . . . . . . . Apply_Method ["simplification","for_polynomials"],
471 . . . . . . . . . . Rewrite_Set "norm_Poly",
473 . . . . . . . . . . Check_Postcond ["polynomial","simplification"],
476 (*/--- final test ---------------------------------------------------------------------------\\*)
477 val (res, asm) = (get_obj g_result pt (fst p));
478 if term2str res = "2 * a" andalso terms2str asm = "[\"a + a is_polyexp\"]"
479 andalso p = ([], Und) andalso msg = "end-of-calculation"
480 andalso pr_ctree pr_short pt = ". ----- pblobj -----\n1. a + a\n"
482 case tac''''' of Check_Postcond ["polynomial", "simplification"] => ()
483 | _ => error "re-build: fun find_next_step, mini 1"
484 else error "re-build: fun find_next_step, mini 2"
487 "----------- re-build: fun locate_input_term ---------------------------------------------------";
488 "----------- re-build: fun locate_input_term ---------------------------------------------------";
489 "----------- re-build: fun locate_input_term ---------------------------------------------------";
491 ----------- appendFormula: on Res + late deriv ------------------------------------------------*)
492 val fmz = ["equality (x+1=(2::real))", "solveFor x","solutions L"];
493 val (dI',pI',mI') = ("Test", ["sqroot-test","univariate","equation","test"],
494 ["Test","squ-equ-test-subpbl1"]);
495 val (p,_,f,nxt,_,pt) = CalcTreeTEST [(fmz, (dI',pI',mI'))];
496 val (p,_,f,nxt,_,pt) = me nxt p [] pt;
497 val (p,_,f,nxt,_,pt) = me nxt p [] pt;
498 val (p,_,f,nxt,_,pt) = me nxt p [] pt;
499 val (p,_,f,nxt,_,pt) = me nxt p [] pt;
500 val (p,_,f,nxt,_,pt) = me nxt p [] pt;
501 val (p,_,f,nxt,_,pt) = me nxt p [] pt;
502 (*[], Met*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*Apply_Method ["Test", "squ-equ-test-subpbl1"]*);
504 (*[1], Frm*)val (p,_,f,nxt,_,pt) = me nxt p [] pt;(*Rewrite_Set "norm_equation"*)
505 (*+*)if f2str f = "x + 1 = 2" then () else error "locate_input_term at ([1], Frm) CHANGED";
507 (*[1], Res*)val (p,_,f,nxt,_,pt) = me nxt p [] pt;(*Rewrite_Set "Test_simplify"*)
508 (*+*)if f2str f = "x + 1 + -1 * 2 = 0" then () else error "locate_input_term at ([1], Frm) CHANGED";
511 ([], Frm), solve (x + 1 = 2, x)
512 . . . . . . . . . . Apply_Method ["Test","squ-equ-test-subpbl1"],
513 ([1], Frm), x + 1 = 2
514 . . . . . . . . . . Rewrite_Set "norm_equation",
515 ([1], Res), x + 1 + -1 * 2 = 0 ///Check_Postcond..ERROR*)
517 (*//---------- appendFormula 1 "x = 1" \<longrightarrow> Step_Solve.inform \<longrightarrow> LI.locate_input_term ----------\\*)
518 "~~~~~ fun appendFormula , args:"; val ((*cI, *) ifo: Rule.cterm') = ((**) "x = 1");
519 val cs = (*get_calc cI*) ((pt, p), [(*nxt, nxt_, (pos, (ist, ctxt))*)])
520 val pos = (*get_pos cI 1*) p
522 (*+*)val ptp''''' = (pt, p);
523 (*+*)if snd ptp''''' = ([1], Res) then () else error "old_cs changed";
524 (*+*)show_pt_tac pt; (*[
525 (*+*)([], Frm), solve (x + 1 = 2, x)
526 (*+*). . . . . . . . . . Apply_Method ["Test","squ-equ-test-subpbl1"],
527 (*+*)([1], Frm), x + 1 = 2
528 (*+*). . . . . . . . . . Rewrite_Set "norm_equation",
529 (*+*)([1], Res), x + 1 + -1 * 2 = 0 ///Check_Postcond*)
531 val ("ok", cs' as (_, _, ptp')) =
532 (*case*) Step.do_next pos cs (*of*);
534 val ("ok", (_(*use in DG !!!*), [], ptp''''' as (pt''''', p'''''))) = (*case*)
535 Step_Solve.by_term ptp' (encode ifo) (*of*);
536 "~~~~~ fun Step_Solve.by_term , args:"; val ((pt, pos as (p, _)), istr)
537 = (ptp', (encode ifo));
539 (*case*) TermC.parse (Celem.assoc_thy "Isac_Knowledge") istr (*of*);
540 val f_in = Thm.term_of f_in
541 val pos_pred = lev_back(*'*) pos
542 val f_pred = Ctree.get_curr_formula (pt, pos_pred);
543 val f_succ = Ctree.get_curr_formula (pt, pos);
544 (*if*) f_succ = f_in (*else*);
546 (*case*) In_Chead.cas_input f_in (*of*);
548 (*old* ) val (_, _, metID) = get_obj g_spec pt (par_pblobj pt p)
549 (*old*) val {scr = prog, ...} = Specify.get_met metID
550 (*old*) val istate = get_istate_LI pt pos
551 (*old*) val ctxt = get_ctxt pt pos
552 val LI.Found_Step (cstate'''''_', _(*istate*), _(*ctxt*)) = (*case*)
553 LI.locate_input_term prog (pt, pos) istate ctxt f_in (*of*);
554 "~~~~~ fun locate_input_term , args:"; val ((Rule.Prog _), ((pt, pos) : Calc.T), (_ : Istate.T), (_ : Proof.context), tm)
555 = (prog, (pt, pos), istate, ctxt, f_in);
558 (*NEW*) LI.locate_input_term (pt, pos) f_in (*of*);
559 "~~~~~ fun locate_input_term , args:"; val ((pt, pos), tm) = ((pt, pos), f_in);
560 val pos_pred = Pos.lev_back' pos (*f_pred ---"step pos cs"---> f_succ in appendFormula*)
562 val ("ok", (_, _, cstate as (pt', pos'))) =
563 (*case*) compare_step ([], [], (pt, pos_pred)) tm (*of*);
566 Found_Step (cstate, get_istate_LI pt' pos', get_ctxt pt' pos') (*return from locate_input_term*);
568 (*NEW*) Found_Step cstate (*return from locate_input_term*);
569 (*LI.Found_Step ( *)cstate(*, _(*istate*), _(*ctxt*))( *return from locate_input_term*);
570 "~~~~~ from fun locate_input_term\<longrightarrow>fun Step_Solve.by_term, return:"; val ("ok", (_(*use in DG !!!*), c, ptp as (_, p)))
571 = (("ok" , ([], [], cstate (* already contains istate, ctxt *))));
573 ("ok", ((*_ use in DG !!!,*) c, ptp(* as (_*), p))(*)*)(*return from Step_Solve.by_term*);
574 "~~~~~ from fun Step_Solve.by_term\<longrightarrow>(fun appendFormula)!toplevel, return:"; val ("ok", (_(*use in DG !!!*), [], ptp''''' as (pt''''', p''''')))
575 = ("ok", ([], [], ptp));
577 (*fun me requires nxt...*)
578 Step.do_next p''''' (ptp''''', []);
579 val ("ok", ([(nxt'''''_' as Check_Postcond ["LINEAR", "univariate", "equation", "test"], _, _)], _,
580 (pt'''''_', p'''''_'))) = Step.do_next p''''' (ptp''''', [])
581 (*\\---------- appendFormula 1 "x = 1" \<longrightarrow> Step_Solve.inform \<longrightarrow> LI.locate_input_term ----------//*)
583 (*//----- REPLACED BY appendFormula 1 "x = 1" \<longrightarrow> Step_Solve.inform \<longrightarrow> LI.locate_input_term -----\\* )
584 (*[2], Res*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = Subproblem ("Test", ["LINEAR", "univariate", "equation", "test"])*)
585 (*[3], Pbl*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = Model_Problem*)
586 (*[3], Pbl*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = Add_Given "equality (-1 + x = 0)"*)
587 (*[3], Pbl*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = Add_Given "solveFor x"*)
588 (*[3], Pbl*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = Add_Find "solutions x_i"*)
589 (*[3], Pbl*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = Specify_Theory "Test"*)
590 (*[3], Pbl*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = Specify_Problem ["LINEAR", "univariate", "equation", "test"]*)
591 (*[3], Pbl*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = Specify_Method ["Test", "solve_linear"]*)
592 (*[3], Met*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = Apply_Method ["Test", "solve_linear"]*)
593 (*[3, 1], Frm*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = Rewrite_Set_Inst (["(''bdv'', x)"], "isolate_bdv")*)
594 (*[3, 1], Res*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = Rewrite_Set "Test_simplify"*)
595 (*[3, 2], Res*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = Check_Postcond ["LINEAR", "univariate", "equation", "test"]*)
596 ( *\\----- REPLACED BY appendFormula 1 "x = 1" \<longrightarrow> Step_Solve.inform \<longrightarrow> LI.locate_input_term -----//*)
598 (*[3], Res*)val (p,_,f,nxt,_,pt) = me nxt'''''_' p'''''_' [] pt'''''_'; (*nxt = Check_elementwise "Assumptions"*)
599 (*[4], Res*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = Check_Postcond ["sqroot-test", "univariate", "equation", "test"]*)
600 (*[], Res*)val (p,_,f,nxt,_,pt) = me nxt p [] pt; (*nxt = End_Proof'*)
602 (*/--- final test ---------------------------------------------------------------------------\\*)
603 if p = ([], Res) andalso f2str f = "[x = 1]" andalso pr_ctree pr_short pt =
604 ". ----- pblobj -----\n" ^
606 "2. x + 1 + -1 * 2 = 0\n" ^
607 "3. ----- pblobj -----\n" ^
608 "3.1. -1 + x = 0\n" ^
609 "3.2. x = 0 + -1 * -1\n" ^
610 "3.2.1. x = 0 + -1 * -1\n" ^
611 "3.2.2. x = 0 + 1\n" (*ATTENTION: see complete Calc below*)
612 then case nxt of End_Proof' => () | _ => error "re-build: fun locate_input_term CHANGED 1"
613 else error "re-build: fun locate_input_term CHANGED 2";
616 ([], Frm), solve (x + 1 = 2, x)
617 . . . . . . . . . . Apply_Method ["Test","squ-equ-test-subpbl1"],
618 ([1], Frm), x + 1 = 2
619 . . . . . . . . . . Rewrite_Set "norm_equation",
620 ([1], Res), x + 1 + -1 * 2 = 0
621 . . . . . . . . . . Rewrite_Set "Test_simplify",
622 ([2], Res), -1 + x = 0
623 . . . . . . . . . . Subproblem (Test, ["LINEAR","univariate","equation","test"]),
624 ([3], Pbl), solve (-1 + x = 0, x)
625 . . . . . . . . . . Apply_Method ["Test","solve_linear"],
626 ([3,1], Frm), -1 + x = 0
627 . . . . . . . . . . Rewrite_Set_Inst ([(''bdv'', x)], "isolate_bdv"),
628 ([3,1], Res), x = 0 + -1 * -1
629 . . . . . . . . . . Derive Test_simplify,
630 ([3,2,1], Frm), x = 0 + -1 * -1
631 . . . . . . . . . . Rewrite ("#: -1 * -1 = 1", "-1 * -1 = 1"),
632 ([3,2,1], Res), x = 0 + 1
633 . . . . . . . . . . Rewrite ("radd_0", "0 + ?k = ?k"),
634 ([3,2,2], Res), x = 1
635 . . . . . . . . . . tac2str not impl. for ?!,
637 . . . . . . . . . . Check_Postcond ["LINEAR","univariate","equation","test"],
639 . . . . . . . . . . Check_Postcond ["sqroot-test","univariate","equation","test"],
640 ([], Res), [x = 1]]*)