doc-src/isac/mat-eng-de.tex
branchlatex-isac-doc
changeset 37889 fe4854d9fdda
parent 37888 97c7a4059d2e
child 37891 6a55c9954896
equal deleted inserted replaced
37888:97c7a4059d2e 37889:fe4854d9fdda
    12 \title{\isac --- Interface for\\
    12 \title{\isac --- Interface for\\
    13   Developers of Math Knowledge\\[1.0ex]
    13   Developers of Math Knowledge\\[1.0ex]
    14   and\\[1.0ex]
    14   and\\[1.0ex]
    15   Tools for Experiments in\\
    15   Tools for Experiments in\\
    16   Symbolic Computation\\[1.0ex]}
    16   Symbolic Computation\\[1.0ex]}
    17 \author{The \isac-Team\\
    17 \author{Alexandra Hirn und Eva Rott\\
    18   \tt isac-users@ist.tugraz.at\\[1.0ex]}
    18   \tt isac-users@ist.tugraz.at\\[1.0ex]}
    19 \date{\today}
    19 \date{\today}
    20 
    20 
    21 \begin{document}
    21 \begin{document}
    22 \maketitle
    22 \maketitle
   763 \end{description}
   763 \end{description}
   764 
   764 
   765 
   765 
   766 
   766 
   767 \chapter{Befehle von \isac{}}
   767 \chapter{Befehle von \isac{}}
   768 In diesem Kapitel werden alle schon zur Verf\"ugung stehenden Schritte aufgelistet. Diese Liste kann sich auf Grund von weiteren Entwicklungen von \isac{} noch \"andern.
   768 In diesem Kapitel werden alle schon zur Verf\"ugung stehenden Schritte aufgelistet. Diese Liste kann sich auf Grund von weiteren Entwicklungen von \isac{} noch \"andern.\
   769 \newline \textbf{Init\_Proof\_Hid (dialogmode, formalization, specifictaion} gibt die eingegebenen Befehle weiter an die mathematic engine, wobei die beiden letzten Begriffe die Beispiele automatisch speichern. Es ist nicht vorgesehen, dass der Sch\"uler die Taktik verwendet.
   769 \newline \textbf{Init\_Proof\_Hid (dialogmode, formalization, specifictaion} gibt die eingegebenen Befehle weiter an die mathematic engine, wobei die beiden letzten Begriffe die Beispiele automatisch speichern. Es ist nicht vorgesehen, dass der Sch\"uler tactic verwendet.\
   770 \newline \textbf{Init\_Proof} bildet mit einem ''proof tree`` ein leeres Modell.
   770 \newline \textbf{Init\_Proof} bildet mit einem ''proof tree`` ein leeres Modell.\
   771 \newline \textbf{Model\_Problem problem} bestimmt ein problemtype, das wom\"oglich in der ''hierachy`` gefunden wurde, und verwendet es f\"u das Umformen.
   771 \newline \textbf{Model\_Problem problem} bestimmt ein problemtype, das wom\"oglich in der ''hierachy`` gefunden wurde, und verwendet es f\"u das Umformen.\
   772 \newline \textbf{Add\_Given, Add\_Find, Add\_Relation formula} f\"ugt eine Formel in ein bestimmtes Feld eines Modells ein. Dies ist notwendig, solange noch kein Objekt f\"ur den Benutzer vorhanden ist, in dem man die Formel eingeben kann, und nicht die gew\"unschte Taktik und Formel von einer Liste w\"ahlen will.
   772 \newline \textbf{Add\_Given, Add\_Find, Add\_Relation formula} f\"ugt eine Formel in ein bestimmtes Feld eines Modells ein. Dies ist notwendig, solange noch kein Objekt f\"ur den Benutzer vorhanden ist, in dem man die Formel eingeben kann, und nicht die gew\"unschte tactic und Formel von einer Liste w\"ahlen will.\
   773 \newline \textbf{Specify\_Theorie theory, Specify\_Problem proble, Specify\_Method method} gibt das entsprechende Element des Basiswissens an.
   773 \newline \textbf{Specify\_Theorie theory, Specify\_Problem proble, Specify\_Method method} gibt das entsprechende Element des Basiswissens an.\
   774 \newline \textbf{Refine\_Problem problem} sucht nach einem Problem in der hierachy, das auf das vorhandene zutrifft.
   774 \newline \textbf{Refine\_Problem problem} sucht nach einem Problem in der hierachy, das auf das vorhandene zutrifft.\
   775 \newline \textbf{Apply\_Method method} beendet das Modell und die Beschreibung. Danach wird die L\"osungmeldung ge\"offnet.
   775 \newline \textbf{Apply\_Method method} beendet das Modell und die Beschreibung. Danach wird die L\"osungmeldung ge\"offnet.\
   776 \newline \textbf{Free\_Solve} beginnt eine L\"osungsmeldung ohne die Hilfe eine method.
   776 \newline \textbf{Free\_Solve} beginnt eine L\"osungsmeldung ohne die Hilfe eine method.\
   777 \newline \textbf{Rewrite theorem} bef\"ordert ein theorem in die aktuelle Formel und wandelt es demenetsprechend um. Wenn dies nicht m\"oglich ist, kommt eine Meldung mit ''error``.
   777 \newline \textbf{Rewrite theorem} bef\"ordert ein theorem in die aktuelle Formel und wandelt es demenetsprechend um. Wenn dies nicht m\"oglich ist, kommt eine Meldung mit ''error``.\
   778 \newline \textbf{Rewrite\_Asm theorem} hat die gleiche Funktion wie Rewrite, speichert jedoch eine endg\"ultige Vorraussetzung des Theorems, anstatt diese zu sch\"atzen.
   778 \newline \textbf{Rewrite\_Asm theorem} hat die gleiche Funktion wie Rewrite, speichert jedoch eine endg\"ultige Vorraussetzung des Theorems, anstatt diese zu sch\"atzen.\
   779 \newline \textbf{Rewrite\_Set ruleset} hat \"ahnliche Funktionen wie Rewrite, gilt aber f\"ur einen ganzen Satz von Theorems, dem rule set.
   779 \newline \textbf{Rewrite\_Set ruleset} hat \"ahnliche Funktionen wie Rewrite, gilt aber f\"ur einen ganzen Satz von Theorems, dem rule set.\
   780 \newline \textbf{Rewrite\_Inst (substitution, theorem), Rewrite\_Set\_Inst (substitution, rule set)} ist vergleichbar mit besonderen Taktiken, ersetzt aber Konstanten in der Theorem, bevor es zu einer Anwendung kommt.
   780 \newline \textbf{Rewrite\_Inst (substitution, theorem), Rewrite\_Set\_Inst (substitution, rule set)} ist vergleichbar mit besonderen tactics, ersetzt aber Konstanten in der Theorem, bevor es zu einer Anwendung kommt.\
   781 
   781 \newline \textbf{Calculate operation} berechnet das Ergebnis der Eingabe mit der aktuellen Formel (plus, minus, times, cancel, pow, sqrt).\
   782 
   782 \newline \textbf{Substitute substitution} f\"ugt substitution der momentanen Formel hinzu und wandelt es um.\
   783 
   783 \newline \textbf{Take formula} startet eine neue Reihe von Rechnungen in den Formeln, wo sich schon eine andere Rechnung befindet.\
   784 
   784 \newline \textbf{Subproblem (theory, problem)} beginnt ein subproblem innerhalb einer Rechnung.\
   785 
   785 \newline \textbf{Function formula} ruft eine Funktion auf, in der der Name in der Formel enthalten ist. ???????\
   786 
   786 \newline \textbf{Split\_And, Conclude\_And, Split\_Or, Conclude\_Or, Begin\_Trans, End\_Trans, Begin\_Sequ, End\_Sequ, Split\_Intersect, End\_Intersect} betreffen den Bau einzelner branches des proof trees. Normalerweise werden sie vom dialog guide verdr\"angt.\
   787 
   787 \newline \textbf{Check\_elementwise assumption} wird in Bezug auf die aktuelle Formel verwendet, die Elemente in einer Liste enth\"alt.\
   788 
   788 \newline \textbf{Or\_to\_List} wandelt eine Verbindung von Gleichungen in eine Liste von Gleichungen um.\
   789 
   789 \newline \textbf{Check\_postcond:} \"uberpr\"uft die momentane Formel im Bezug auf die Nachbedinung beim beenden des subproblem.\
   790 \newpage
   790 \newline \textbf{End\_Proof} beendet eine \"Uberpr\"ufung und gibt erst dann ein Ergebnis aus, wenn Check\_postcond erfolgreich abgeschlossen wurde.
   791 ------------------------------- ALTER TEXT -------------------------------
   791 
   792 
   792 \section{Die Funktionsweise der mathematic engine}
   793 \chapter{Do a calculational proof}
   793 Ein proof (= Beweis) wird in der mathematic engine {\tt me} von der tactic {\tt Init\_Proof} gestartet und wird wechselwirkend mit anderen tactics vornagebracht. Auf den input (= das, was eingegeben wurde) einzelner tactics folgt eine Formel, die von der {\tt me} ausgegeben wird, und die darauf folgende tactic gilt. Der proof ist beendet, sobald die {\tt me} {\tt End\_Proof} als n\"achste tactic vorschl\"agt.
   794 First we list all the tactics available so far (this list may be extended during further development of \isac).
   794 \newline Im Anschluss werden Sie einen Rechenbeweis sehen, der von der L\"osung einer Gleichung (= equation) handelt, bei der diese automatisch differenziert wird. 
   795 
   795 {\footnotesize\begin{verbatim}
   796 \section{Tactics for doing steps in calculations}
   796 ??????????????????????????????????????????????????????????????????????????????????   
   797 \input{tactics}
   797 
   798 
   798 ML> val fmz = ["equality ((x+#1)*(x+#2)=x^^^#2+#8)","solveFor x",
   799 \section{The functionality of the math engine}
       
   800 A proof is being started in the math engine {\tt me} by the tactic
       
   801 \footnote{In the present version a tactic is of type {\tt mstep}.}
       
   802  {\tt Init\_Proof}, and interactively promoted by other tactics. On input of each tactic the {\tt me} returns the resulting formula and the next tactic applicable. The proof is finished, when the {\tt me} proposes {\tt End\_Proof} as the next tactic.
       
   803 
       
   804 We show a calculation (calculational proof) concerning equation solving, where the type of equation is refined automatically: The equation is given by the respective formalization ...
       
   805 {\footnotesize\begin{verbatim}
       
   806    ML> val fmz = ["equality ((x+#1)*(x+#2)=x^^^#2+#8)","solveFor x",
       
   807                   "errorBound (eps=#0)","solutions L"];
   799                   "errorBound (eps=#0)","solutions L"];
   808    val fmz =
   800    val fmz =
   809      ["equality ((x+#1)*(x+#2)=x^^^#2+#8)","solveFor x","errorBound (eps=#0)",
   801      ["equality ((x+#1)*(x+#2)=x^^^#2+#8)","solveFor x","errorBound (eps=#0)",
   810       "solutions L"] : string list
   802       "solutions L"] : string list
   811    ML>
   803    ML>
   812    ML> val spec as (dom, pbt, met) = ("SqRoot.thy",["univariate","equation"],
   804    ML> val spec as (dom, pbt, met) = ("SqRoot.thy",["univariate","equation"],
   813                                  ("SqRoot.thy","no_met"));
   805                                  ("SqRoot.thy","no_met"));
   814    val dom = "SqRoot.thy" : string
   806    val dom = "SqRoot.thy" : string
   815    val pbt = ["univariate","equation"] : string list
   807    val pbt = ["univariate","equation"] : string list
   816    val met = ("SqRoot.thy","no_met") : string * string
   808    val met = ("SqRoot.thy","no_met") : string * string
   817 \end{verbatim}}%size
   809 \end{verbatim}
   818 ... and the specification {\tt spec} of a domain {\tt dom}, a problem type {\tt pbt} and a method {\tt met}. Note that the equation is such, that it is not immediatly clear, what type it is in particular (it could be a polynomial of degree 2; but, for sure, the type is some specialized type of a univariate equation). Thus, no method ({\tt no\_met}) can be specified for solving the problem.
   810 
   819 
   811 \section{Der Beginn einer Rechnung}
   820 Nevertheless this specification is sufficient for automatically solving the equation --- the appropriate method will be found by refinement within the hierarchy of problem types.
   812 Um einen neuen proof beginnen zu k\"onnen, werden folgende Schritte durchgef\"uhrt:
   821 
   813 Der proof state wird von einem proof tree und einer position ausgegeben. Beide sind zu Beginn leer. Die tactic {\tt Init\_Proof} ist, wie alle anderen tactics auch, an einen string gekoppelt.
   822 
   814 \footnotesize\begin{verbatim}
   823 \section{Initialize the calculation}
   815 ???????????????????????????????????????????????????????????????????????????????????????????? 
   824 The start of a new proof requires the following initializations: The proof state is given by a proof tree {\tt ptree} and a position {\tt pos'}; both are empty at the beginning. The tactic {\tt Init\_Proof} is, like all other tactics, paired with an identifier of type {\tt string} for technical reasons.
   816 ML>  val (mID,m) = ("Init_Proof",Init_Proof (fmz, (dom,pbt,met)));
   825 {\footnotesize\begin{verbatim}
       
   826    ML>  val (mID,m) = ("Init_Proof",Init_Proof (fmz, (dom,pbt,met)));
       
   827    val mID = "Init_Proof" : string
   817    val mID = "Init_Proof" : string
   828    val m =
   818    val m =
   829      Init_Proof
   819      Init_Proof
   830        (["equality ((x+#1)*(x+#2)=x^^^#2+#8)","solveFor x","errorBound (eps=#0)",
   820        (["equality ((x+#1)*(x+#2)=x^^^#2+#8)","solveFor x","errorBound (eps=#0)",
   831          "solutions L"],("SqRoot.thy",[#,#],(#,#))) : mstep
   821          "solutions L"],("SqRoot.thy",[#,#],(#,#))) : mstep
   838    val pt =
   828    val pt =
   839      Nd
   829      Nd
   840        (PblObj
   830        (PblObj
   841           {branch=#,cell=#,env=#,loc=#,meth=#,model=#,origin=#,ostate=#,probl=#,
   831           {branch=#,cell=#,env=#,loc=#,meth=#,model=#,origin=#,ostate=#,probl=#,
   842            result=#,spec=#},[]) : ptree
   832            result=#,spec=#},[]) : ptree
   843    \end{verbatim}}%size
   833 \end{verbatim}
   844 The mathematics engine {\tt me} returns the resulting formula {\tt f} of type {\tt mout} (which in this case is a problem), the next tactic {\tt nxt}, and a new proof state ({\tt ptree}, {\tt pos'}).
   834 Die mathematics engine gibt etwas mit dem type {\tt mout} aus, was in unserem Fall ein Problem darstellt. Sobald die Schriftgr\"osse ge\"andert wird, m\"usste dieses jedoch gel\"ost sein.
   845 
   835 \footnotesize\begin{verbatim}
   846 We can convince ourselves, that the problem is still empty, by increasing {\tt Compiler.Control.Print.printDepth}:
   836 ?????????????????????????????????????????????????????????????????????????????????????????????
   847 {\footnotesize\begin{verbatim}
       
   848    ML> Compiler.Control.Print.printDepth:=8; (*4 default*)
   837    ML> Compiler.Control.Print.printDepth:=8; (*4 default*)
   849    val it = () : unit
   838    val it = () : unit
   850    ML>
   839    ML>
   851    ML> f;
   840    ML> f;
   852    val it =
   841    val it =
   855           (0,EdUndef,0,Nundef,
   844           (0,EdUndef,0,Nundef,
   856            (Problem [],
   845            (Problem [],
   857             {Find=[Incompl "solutions []"],
   846             {Find=[Incompl "solutions []"],
   858              Given=[Incompl "equality",Incompl "solveFor"],Relate=[],
   847              Given=[Incompl "equality",Incompl "solveFor"],Relate=[],
   859              Where=[False "matches (?a = ?b) e_"],With=[]}))) : mout
   848              Where=[False "matches (?a = ?b) e_"],With=[]}))) : mout
   860 \end{verbatim}}%size
   849 \end{verbatim}
   861 Recall, please, the format of a problem as presented in sect.\ref{pbl} on p.\pageref{pbl}; such an 'empty' problem can be found above encapsulated by several constructors containing additional data (necessary for the dialog guide, not relevant here).\\
   850 {\footnotesize\begin{verbatim}
   862 
   851 ?????????????????????????????????????????????????????????????????????????????????????????????
   863 {\it In the sequel we will omit output of the {\tt me} if it is not important for the respective context}.\\
       
   864 
       
   865 In general, the dialog guide will hide the following two tactics {\tt Refine\_Tacitly} and {\tt Model\_Problem} from the user.
       
   866 {\footnotesize\begin{verbatim}
       
   867    ML>  nxt;
   852    ML>  nxt;
   868    val it = ("Refine_Tacitly",Refine_Tacitly ["univariate","equation"])
   853    val it = ("Refine_Tacitly",Refine_Tacitly ["univariate","equation"])
   869      : string * mstep
   854      : string * mstep
   870    ML>
   855    ML>
   871    ML>  val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
   856    ML>  val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
   872    val nxt = ("Model_Problem",Model_Problem ["normalize","univariate","equation"])
   857    val nxt = ("Model_Problem",Model_Problem ["normalize","univariate","equation"])
   873      : string * mstep
   858      : string * mstep
   874    ML>
   859    ML>
   875    ML>  val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
   860    ML>  val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
   876 \end{verbatim}}%size
   861 \end{verbatim}
   877 
   862 
   878 
   863 \section{The phase of modeling}
   879 \section{The phase of modeling} 
   864 Dieses Kapitel besch\"aftigt sich mit dem input der Einzelheiten bei einem Problem. Die {\tt me} kann dabei helfen, wenn man die formalization durch {\tt Init\_Proof} darauf hinweist. Normalerweise weiss die mathematic engine die n\"achste gute tactic.
   880 comprises the input of the items of the problem; the {\tt me} can help by use of the formalization tacitly transferred by {\tt Init\_Proof}. In particular, the {\tt me} in general 'knows' the next promising tactic; the first one has been returned by the (hidden) tactic {\tt Model\_Problem}.
   865 {\footnotesize\begin{verbatim}
   881 
   866 ?????????????????????????????????????????????????????????????????????????????????????????????
   882 {\footnotesize\begin{verbatim}
       
   883    ML>  nxt;
   867    ML>  nxt;
   884    val it =
   868    val it =
   885      ("Add_Given",Add_Given "equality ((x + #1) * (x + #2) = x ^^^ #2 + #8)")
   869      ("Add_Given",Add_Given "equality ((x + #1) * (x + #2) = x ^^^ #2 + #8)")
   886      : string * mstep
   870      : string * mstep
   887    ML>
   871    ML>
   891    ML>  val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
   875    ML>  val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
   892    val nxt = ("Add_Find",Add_Find "solutions L") : string * mstep
   876    val nxt = ("Add_Find",Add_Find "solutions L") : string * mstep
   893    ML>
   877    ML>
   894    ML>  val (p,_,f,nxt,_,pt) = me nxt p [1] pt; 
   878    ML>  val (p,_,f,nxt,_,pt) = me nxt p [1] pt; 
   895    val f = Form' (PpcKF (0,EdUndef,0,Nundef,(#,#))) : mout
   879    val f = Form' (PpcKF (0,EdUndef,0,Nundef,(#,#))) : mout
   896 \end{verbatim}}%size
   880 \end{verbatim}
   897 \noindent Now the problem is 'modeled', all items are input. We convince ourselves by increasing {\tt Compiler.Control.Print.printDepth} once more.
   881 {\footnotesize\begin{verbatim}
   898 {\footnotesize\begin{verbatim}
   882 ?????????????????????????????????????????????????????????????????????????????????????????????
   899    ML>  Compiler.Control.Print.printDepth:=8;
   883    ML>  Compiler.Control.Print.printDepth:=8;
   900    ML>  f;
   884    ML>  f;
   901    val it =
   885    val it =
   902      Form'
   886      Form'
   903        (PpcKF
   887        (PpcKF
   904           (0,EdUndef,0,Nundef,
   888           (0,EdUndef,0,Nundef,
   905            (Problem [],
   889            (Problem [],
   906             {Find=[Correct "solutions L"],
   890             {Find=[Correct "solutions L"],
   907              Given=[Correct "equality ((x + #1) * (x + #2) = x ^^^ #2 + #8)",
   891              Given=[Correct "equality ((x + #1) * (x + #2) = x ^^^ #2 + #8)",
   908                     Correct "solveFor x"],Relate=[],Where=[],With=[]}))) : mout
   892                     Correct "solveFor x"],Relate=[],Where=[],With=[]}))) : mout
   909 \end{verbatim}}%size
   893 \end{verbatim}
   910 %One of the input items is considered {\tt Superfluous} by the {\tt me} consulting the problem type {\tt ["univariate","equation"]}. The {\tt ErrorBound}, however, could become important in case the equation only could be solved by some iteration method.
   894 
   911 
   895 
   912 \section{The phase of specification} 
   896 \section{The phase of specification}
   913 This phase provides for explicit determination of the domain, the problem type, and the method to be used. In particular, the search for the appropriate problem type is being supported. There are two tactics for this purpose: {\tt Specify\_Problem} generates feedback on how a candidate of a problem type matches the current problem, and {\tt Refine\_Problem} provides help by the system, if the user gets lost.
   897 Diese phase liefert eindeutige Bestimmungen einer Domäne, den problem type und die method damit man sie verwenden kann. F\"ur gew\"ohnlich wird die Suche nach dem richtigen problem type unterst\"utzt. Dazu sind zwei tactics verwendbar: {\tt Specify\_Problem} entwickelt ein Feedback, wie ein problem type bei dem jetzigen Problem zusammenpasst und {\tt Refine\_Problem} stellt Hilfe durch das System bereit, falls der Benutzer die \"Ubersicht verliert.
   914 {\footnotesize\begin{verbatim}
   898 {\footnotesize\begin{verbatim}
   915 ML> nxt;
   899 ??????????????????????????????????????????????????????????????????????????????????????????
       
   900    ML> nxt;
   916    val it = ("Specify_Domain",Specify_Domain "SqRoot.thy") : string * mstep
   901    val it = ("Specify_Domain",Specify_Domain "SqRoot.thy") : string * mstep
   917    ML>
   902    ML>
   918    ML> val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
   903    ML> val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
   919    val nxt =
   904    val nxt =
   920      ("Specify_Problem",Specify_Problem ["normalize","univariate","equation"])
   905      ("Specify_Problem",Specify_Problem ["normalize","univariate","equation"])
   922    val pt =
   907    val pt =
   923      Nd
   908      Nd
   924        (PblObj
   909        (PblObj
   925           {branch=#,cell=#,env=#,loc=#,meth=#,model=#,origin=#,ostate=#,probl=#,
   910           {branch=#,cell=#,env=#,loc=#,meth=#,model=#,origin=#,ostate=#,probl=#,
   926               result=#,spec=#},[]) : ptree
   911               result=#,spec=#},[]) : ptree
   927 \end{verbatim}}%size
   912 \end{verbatim}
   928 The {\tt me} is smart enough to know the appropriate problem type (transferred tacitly with {\tt Init\_Proof}). In order to challenge the student, the dialog guide may hide this information; then the {\tt me} works as follows.
   913 Die {\tt me} erkennt den richtigen Problem type und arbeitet so weiter:
   929 {\footnotesize\begin{verbatim}
   914 {\footnotesize\begin{verbatim}
       
   915 ?????????????????????????????????????????????????????????????????????????????????????????
   930    ML> val nxt = ("Specify_Problem",
   916    ML> val nxt = ("Specify_Problem",
   931                Specify_Problem ["polynomial","univariate","equation"]);
   917                Specify_Problem ["polynomial","univariate","equation"]);
   932    ML> val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
   918    ML> val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
   933    val f = Form' (PpcKF (0,EdUndef,0,Nundef,(#,#))) : mout
   919    val f = Form' (PpcKF (0,EdUndef,0,Nundef,(#,#))) : mout
   934    val nxt =
   920    val nxt =
   947              Given=[Correct "equality ((x + #1) * (x + #2) = x ^^^ #2 + #8)",
   933              Given=[Correct "equality ((x + #1) * (x + #2) = x ^^^ #2 + #8)",
   948                     Correct "solveFor x"],Relate=[],
   934                     Correct "solveFor x"],Relate=[],
   949              Where=[False
   935              Where=[False
   950                     "matches (?a + ?b * x = #0) ((x + #1) * (x + #2) = x ^^^ #2 + #8)"],
   936                     "matches (?a + ?b * x = #0) ((x + #1) * (x + #2) = x ^^^ #2 + #8)"],
   951              With=[]}))) : mout 
   937              With=[]}))) : mout 
   952 \end{verbatim}}%size
   938 \end{verbatim}
   953 Again assuming that the dialog guide hide the next tactic proposed by the {\tt me}, and the student gets lost, {\tt Refine\_Problem} always 'knows' the way out, if applied to the problem type {\tt["univariate","equation"]}.
   939 Wir nehmen wieder an, dass der dialog guide die n\"achsten tactics, veranlasst von der mathematic engine, versteckt und der Sch\"uler Hilfe ben\"otigt. Dann muss {\tt Refine\_Problem} angewandt werden. Dieser Befehl findet immer den richtigen Weg, wenn man es auf den problem type bezieht [''univariate``, ''equation``].
   954 {\footnotesize\begin{verbatim}
   940 {\footnotesize\begin{verbatim}
       
   941 ????????????????????????????????????????????????????????????????????????????????????????????
   955    ML> val nxt = ("Refine_Problem",
   942    ML> val nxt = ("Refine_Problem",
   956                   Refine_Problem ["linear","univariate","equation
   943                   Refine_Problem ["linear","univariate","equation
   957    ML> val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
   944    ML> val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
   958    val f = Problems (RefinedKF [NoMatch #]) : mout
   945    val f = Problems (RefinedKF [NoMatch #]) : mout
   959    ML>
   946    ML>
  1003            Matches
   990            Matches
  1004              (["normalize","univariate","equation"],
   991              (["normalize","univariate","equation"],
  1005               {Find=[Correct "solutions L"],
   992               {Find=[Correct "solutions L"],
  1006                Given=[Correct "equality ((x + #1) * (x + #2) = x ^^^ #2 + #8)",
   993                Given=[Correct "equality ((x + #1) * (x + #2) = x ^^^ #2 + #8)",
  1007                       Correct "solveFor x"],Relate=[],Where=[],With=[]})]) : mout
   994                       Correct "solveFor x"],Relate=[],Where=[],With=[]})]) : mout
  1008 \end{verbatim}}%size
   995 \end{verbatim}
  1009 The tactic {\tt Refine\_Problem} returns all matches to problem types along the path traced in the problem hierarchy (anlogously to the authoring tool for refinement in sect.\ref{refine} on p.\pageref{refine}) --- a lot of information to be displayed appropriately in the hiearchy browser~!
   996 Die tactic {\tt Refine\_Problem} wandelt alle matches wieder in problem types um und sucht in der problem hierachy weiter.
  1010 
   997 
  1011 \section{The phase of solving} 
   998 
  1012 This phase starts by invoking a method, which acchieves the normal form within two tactics, {\tt Rewrite rnorm\_equation\_add} and {\tt Rewrite\_Set SqRoot\_simplify}:
   999 \section{The phase of solving}
       
  1000 Diese phase beginnt mit dem Aufruf einer method, die eine normale form innarhalb einer tactic ausf\"uhrt: {\tt Rewrite rnorm\_equation\_add} and {\tt Rewrite\_Set SqRoot\_simplify}:
  1013 {\footnotesize\begin{verbatim} 
  1001 {\footnotesize\begin{verbatim} 
  1014    ML> nxt;
  1002    ML> nxt;
  1015    val it = ("Apply_Method",Apply_Method ("SqRoot.thy","norm_univar_equation"))
  1003    val it = ("Apply_Method",Apply_Method ("SqRoot.thy","norm_univar_equation"))
  1016      : string * mstep
  1004      : string * mstep
  1017    ML>
  1005    ML>
  1029    val nxt = ("Rewrite_Set",Rewrite_Set "SqRoot_simplify") : string * mstep
  1017    val nxt = ("Rewrite_Set",Rewrite_Set "SqRoot_simplify") : string * mstep
  1030    ML>
  1018    ML>
  1031    ML>  val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
  1019    ML>  val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
  1032    val f = Form' (FormKF (~1,EdUndef,1,Nundef,"#-6 + #3 * x = #0")) : mout
  1020    val f = Form' (FormKF (~1,EdUndef,1,Nundef,"#-6 + #3 * x = #0")) : mout
  1033    val nxt = ("Subproblem",Subproblem ("SqRoot.thy",[#,#])) : string * mstep
  1021    val nxt = ("Subproblem",Subproblem ("SqRoot.thy",[#,#])) : string * mstep
  1034 \end{verbatim}}%size
  1022 \end{verbatim}
  1035 Now the normal form {\tt \#-6 + \#3 * x = \#0} is the input to a subproblem, which again allows for specification of the type of equation, and the respective method:
  1023 Die Formel $-6 + 3 * x = 0$ ist die Eingabe eine subproblems, das wiederum gebraucht wird, um die Gleichungsart zu erkennen und die entsprechende method auszuf\"uhren:
  1036 {\footnotesize\begin{verbatim}
  1024 {\footnotesize\begin{verbatim}
  1037    ML> nxt;
  1025    ML> nxt;
  1038    val it = ("Subproblem",Subproblem ("SqRoot.thy",["univariate","equation"]))
  1026    val it = ("Subproblem",Subproblem ("SqRoot.thy",["univariate","equation"]))
  1039    ML>   
  1027    ML>   
  1040    ML> val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
  1028    ML> val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
  1044      : mout
  1032      : mout
  1045    val nxt = ("Refine_Tacitly",Refine_Tacitly ["univariate","equation"])
  1033    val nxt = ("Refine_Tacitly",Refine_Tacitly ["univariate","equation"])
  1046    ML>
  1034    ML>
  1047    ML> val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
  1035    ML> val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
  1048    val nxt = ("Model_Problem",Model_Problem ["linear","univariate","equation"])
  1036    val nxt = ("Model_Problem",Model_Problem ["linear","univariate","equation"])
  1049 \end{verbatim}}%size
  1037 \end{verbatim}
  1050 As required, the tactic {\tt Refine ["univariate","equation"]} selects the appropriate type of equation from the problem hierarchy, which can be seen by the tactic {\tt Model\_Problem ["linear","univariate","equation"]} prosed by the system.
  1038 {\tt Refine [''univariate``, ''equation``]} sucht die passende Gleichungsart aus der problem hierachy heraus, welche man mit {\tt Model\_Problem [''linear``, ''univariate``, ''equation``]} \"uber das System ansehen kann.
  1051 
  1039 Nun folgt erneut die phase of modeling und die phase of specification.
  1052 Again the whole phase of modeling and specification follows; we skip it here, and \isac's dialog guide may decide to do so as well.
  1040 
  1053 
  1041 \section{The final phase: \"Uberpr\"ufung der ''post-condition``}
  1054 
  1042 Die gezeigten problems, die durch \isac{} gel\"ost wurden, sind so genannte 'example construction problems'. Das massivste Merkmal solcher problems ist die post-condition. Im Umgang mit dieser gibt es in diesem Zusammenhang noch offene Fragen.
  1055 \section{The final phase: check the post-condition}
  1043 Dadurch wird die post-condition im folgenden Beispiel als problem und subproblem erw\"ahnt.
  1056 The type of problems solved by \isac{} are so-called 'example construction problems' as shown above. The most characteristic point of such a problem is the post-condition. The handling of the post-condition in the given context is an open research question.
       
  1057 
       
  1058 Thus the post-condition is just mentioned, in our example for both, the problem and the subproblem:
       
  1059 {\footnotesize\begin{verbatim}
  1044 {\footnotesize\begin{verbatim}
  1060    ML> nxt;
  1045    ML> nxt;
  1061    val it = ("Check_Postcond",Check_Postcond ["linear","univariate","equation"])
  1046    val it = ("Check_Postcond",Check_Postcond ["linear","univariate","equation"])
  1062    ML>
  1047    ML>
  1063    ML>  val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
  1048    ML>  val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
  1066      ("Check_Postcond",Check_Postcond ["normalize","univariate","equation"])
  1051      ("Check_Postcond",Check_Postcond ["normalize","univariate","equation"])
  1067    ML>
  1052    ML>
  1068    ML>  val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
  1053    ML>  val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
  1069    val f = Form' (FormKF (~1,EdUndef,0,Nundef,"[x = #2]")) : mout
  1054    val f = Form' (FormKF (~1,EdUndef,0,Nundef,"[x = #2]")) : mout
  1070    val nxt = ("End_Proof'",End_Proof') : string * mstep
  1055    val nxt = ("End_Proof'",End_Proof') : string * mstep
  1071 \end{verbatim}}%size
  1056 \end{verbatim}
  1072 The next tactic proposed by the system, {\tt End\_Proof'} indicates that the proof has finished successfully.\\
  1057 Die tactic {\tt End\_Proof'} bedeutet, dass der proof erflogreich beendet wurde.\\
  1073 
  1058 
  1074 {\it The tactics proposed by the system need {\em not} be followed by the user; the user is free to choose other tactics, and the system will report, if this is applicable at the respective proof state, or not~! The reader may try out~!}
  1059 {\it Die tactics, die vom System vorgeschlagen werden, m\"ussen vom Benutzer nicht angewendet werden. Er kann selbstverst\"andlich auch andere tactics verwenden und das System wird melden, ob dieser Befehl zutreffend ist oder nicht. Man sollte unbedingt selbst verschiedene Beispiele ausprobieren!}
  1075 
  1060 
  1076 
  1061 
  1077 
  1062 \part{Systematische Beschreibung}
  1078 \part{Systematic description}
  1063 
  1079 
  1064 \chapter{Die Struktur des Grundlagenwissens}
  1080 
  1065 
  1081 \chapter{The structure of the knowledge base}
  1066 \section{Taktiken und Daten}
  1082 
  1067 Zuerst betrachten wir das ME von außen. Wir sehen uns Taktiken und an und verbinden sie mit unserem Grundwissen (KB). Im Bezug auf das KB befassen wir uns mit den kleinsten Teilchen, die von den Autoren des KB sehr genau durchgef\"uhrt werden m\"ussen.
  1083 \section{Tactics and data}
  1068 Diese Teile sind in alphabetischer Anordnung in Tab.\ref{kb-items} auf Seite \pageref{kb-items} aufgelistet.
  1084 First we view the ME from outside, i.e. we regard tactics and relate them to the knowledge base (KB). W.r.t. the KB we address the atomic items which have to be implemented in detail by the authors of the KB
  1069 
  1085 \footnote{Some of these items are fetched by the tactics from intermediate storage within the ME, and not directly from the KB.}
       
  1086 . The items are listed in alphabetical order in Tab.\ref{kb-items} on p.\pageref{kb-items}.
       
  1087 {\begin{table}[h]
  1070 {\begin{table}[h]
  1088 \caption{Atomic items of the KB} \label{kb-items}
  1071 \caption{Kleinste Teilchen des KB} \label{kb-items}
  1089 %\tabcolsep=0.3mm
  1072 %\tabcolsep=0.3mm
  1090 \begin{center}
  1073 \begin{center}
  1091 \def\arraystretch{1.0}
  1074 \def\arraystretch{1.0}
  1092 \begin{tabular}{lp{9.0cm}}
  1075 \begin{tabular}{lp{9.0cm}}
  1093 abbrevation & description \\
  1076 Abk\"urzung & Beschreibung \\
  1094 \hline
  1077 \hline
  1095 &\\
  1078 &\\
  1096 {\it calc\_list}
  1079 {\it calc\_list}
  1097 & associationlist of the evaluation-functions {\it eval\_fn}\\
  1080 & gesammelte Liste von allen ausgewerteten Funktionen {\it eval\_fn}\\
  1098 {\it eval\_fn}
  1081 {\it eval\_fn}
  1099 & evaluation-function for numerals and for predicates coded in SML\\
  1082 & ausgewertete Funktionen f\"r Zahlen und f\"ur Eigenschaften, die in SML kodiert sind\\
  1100 {\it eval\_rls   }
  1083 {\it eval\_rls }
  1101 & ruleset {\it rls} for simplifying expressions with {\it eval\_fn}s\\
  1084 & Regelsatz {\it rls} f\"ur einfache Ausdr\"ucke mit {\it eval\_fn}s\\
  1102 {\it fmz}
  1085 {\it fmz}
  1103 & formalization, i.e. a minimal formula representation of an example \\
  1086 & Formalisierung, d.h. eine sehr geringe Darstellung von einem Beispiel \\
  1104 {\it met}
  1087 {\it met}
  1105 & a method, i.e. a datastructure holding all informations for the solving phase ({\it rew\_ord}, {\it scr}, etc.)\\
  1088 & eine Methode d.h. eine Datenstruktur, die alle Informationen zum L\"osen einer Phase enth\"alt ({\it rew\_ord}, {\it scr}, etc.)\\
  1106 {\it metID}
  1089 {\it metID}
  1107 & reference to a {\it met}\\
  1090 & bezieht sich auf {\it met}\\
  1108 {\it op}
  1091 {\it op}
  1109 & operator as key to an {\it eval\_fn} in a {\it calc\_list}\\
  1092 & ein Operator, der der Schl\"ussel zu {\it eval\_fn} in einer {\it calc\_list} ist \\
  1110 {\it pbl}
  1093 {\it pbl}
  1111 & problem, i.e. a node in the problem-hierarchy\\
  1094 & Problem d.h. der Knotenpunkt in der Hierarchie von Problemen\\
  1112 {\it pblID}
  1095 {\it pblID}
  1113 & reference to a {\it pbl}\\
  1096 & bezieht sich auf {\it pbl}\\
  1114 {\it rew\_ord}
  1097 {\it rew\_ord}
  1115 & rewrite-order\\
  1098 & Anordnung beim Rewriting\\
  1116 {\it rls}
  1099 {\it rls}
  1117 & ruleset, i.e. a datastructure holding theorems {\it thm} and operators {\it op} for simplification (with a {\it rew\_ord})\\
  1100 & Regelsatz, d.h. eine Datenstruktur, die Theoremss {\it thm} und Operatoren {\it op} zur Vereinfachuing (mit {\it rew\_ord}) enth\"alt \\
  1118 {\it Rrls}
  1101 {\it Rrls}
  1119 & ruleset for 'reverse rewriting' (an \isac-technique generating stepwise rewriting, e.g. for cancelling fractions)\\
  1102 & Regelsatz f\"ur das 'reverse rewriting' (eine \isac-Technik, die das schrittweise Rewriting entwickelt, z.B. f\"ur die zur\"uckgenommenen Teile)\\
  1120 {\it scr}
  1103 {\it scr}
  1121 & script describing algorithms by tactics, part of a {\it met} \\
  1104 & Skript, das die Algorithmen durch Anwenden von Taktiken beschreibt und ein Teil von {\it met} ist \\
  1122 {\it norm\_rls}
  1105 {\it norm\_rls}
  1123 & special ruleset calculating a normalform, associated with a {\it thy}\\
  1106 & spezielles Regelwerk zum Berechnen von Normalformen, im Zusammenhang mit {\it thy}\\
  1124 {\it spec}
  1107 {\it spec}
  1125 & specification, i.e. a tripel ({\it thyID, pblID, metID})\\
  1108 & Spezifikation, z.B, ein Tripel ({\it thyID, pblID, metID})\\
  1126 {\it subs}
  1109 {\it subs}
  1127 & substitution, i.e. a list of variable-value-pairs\\
  1110 & Ersatz, z.B. eine Liste von Variablen und ihren jeweiligen Werten\\
  1128 {\it term}
  1111 {\it term}
  1129 & Isabelle term, i.e. a formula\\
  1112 & Term von Isabelle, z.B. eine Formel\\
  1130 {\it thm}
  1113 {\it thm}
  1131 & theorem\\     
  1114 & theorem\\
  1132 {\it thy}
  1115 {\it thy}
  1133 & theory\\
  1116 & Theorie\\
  1134 {\it thyID}
  1117 {\it thyID}
  1135 & reference to a {\it thy} \\
  1118 & im Bezug auf {\it thy} \\
  1136 \end{tabular}\end{center}\end{table}
  1119 \end{tabular}\end{center}\end{table}}
  1137 }
  1120 
  1138 The relations between tactics and data items are shown in Tab.\ref{tac-kb}on p.\pageref{tac-kb}.
  1121 Die Verbindung zwischen Taktiken und Daten werden in Tab.\ref{tac-kb} auf Seite \pageref{tac-kb} dargestellt.
  1139 {\def\arraystretch{1.2}
  1122 
       
  1123 
  1140 \begin{table}[h]
  1124 \begin{table}[h]
  1141 \caption{Which tactic uses which KB's item~?} \label{tac-kb}
  1125 \caption{Welche Taktiken verwenden die Teile des KB~?} \label{tac-kb}
  1142 \tabcolsep=0.3mm
  1126 \tabcolsep=0.3mm
  1143 \begin{center}
  1127 \begin{center}
  1144 \begin{tabular}{|ll||cccc|ccc|cccc|} \hline
  1128 \begin{tabular}{|ll||cccc|ccc|cccc|} \hline
  1145 tactic  &input &    &    &    &norm\_&   &rew\_&rls &eval\_&eval\_&calc\_&   \\
  1129 Taktik &Eingabe & & & &norm\_& &rew\_&rls &eval\_&eval\_&calc\_& \\
  1146         &      &thy &scr &Rrls&rls  &thm &ord  &Rrls&fn    &rls   &list  &dsc\\
  1130 & &thy &scr &Rrls&rls &thm &ord &Rrls&fn &rls &list &dsc\\
  1147 \hline\hline
  1131 \hline\hline
  1148 Init\_Proof
  1132 Init\_Proof
  1149         &fmz   & x  &    &    & x   &    &     &    &      &      &      & x \\
  1133 &fmz & x & & & x & & & & & & & x \\
  1150         &spec  &    &    &    &     &    &     &    &      &      &      &   \\
  1134 &spec & & & & & & & & & & & \\
  1151 \hline
  1135 \hline
  1152 \multicolumn{13}{|l|}{model phase}\\
  1136 \multicolumn{13}{|l|}{model phase}\\
  1153 \hline
  1137 \hline
  1154 Add\_*  &term  & x  &    &    & x   &    &     &    &      &      &      & x \\
  1138 Add\_*
  1155 FormFK  &model & x  &    &    & x   &    &     &    &      &      &      & x \\
  1139 &term & x & & & x & & & & & & & x \\
       
  1140 FormFK &model & x & & & x & & & & & & & x \\
  1156 \hline
  1141 \hline
  1157 \multicolumn{13}{|l|}{specify phase}\\
  1142 \multicolumn{13}{|l|}{specify phase}\\
  1158 \hline
  1143 \hline
  1159 Specify\_Theory 
  1144 Specify\_Theory
  1160         &thyID & x  &    &    & x   &    &     &    & x    & x    &      & x \\
  1145 &thyID & x & & & x & & & & x & x & & x \\
  1161 Specify\_Problem 
  1146 Specify\_Problem
  1162         &pblID & x  &    &    & x   &    &     &    & x    & x    &      & x \\
  1147 &pblID & x & & & x & & & & x & x & & x \\
  1163 Refine\_Problem 
  1148 Refine\_Problem
  1164            &pblID & x  &    &    & x   &    &     &    & x    & x    &      & x \\
  1149 &pblID & x & & & x & & & & x & x & & x \\
  1165 Specify\_Method 
  1150 Specify\_Method
  1166         &metID & x  &    &    & x   &    &     &    & x    & x    &      & x \\
  1151 &metID & x & & & x & & & & x & x & & x \\
  1167 Apply\_Method 
  1152 Apply\_Method
  1168         &metID & x  & x  &    & x   &    &     &    & x    & x    &      & x \\
  1153 &metID & x & x & & x & & & & x & x & & x \\
  1169 \hline
  1154 \hline
  1170 \multicolumn{13}{|l|}{solve phase}\\
  1155 \multicolumn{13}{|l|}{solve phase}\\
  1171 \hline
  1156 \hline
  1172 Rewrite,\_Inst 
  1157 Rewrite,\_Inst
  1173         &thm   & x  & x  &    &     & x  &met  &    & x    &met   &      &   \\
  1158 &thm & x & x & & & x &met & & x &met & & \\
  1174 Rewrite, Detail
  1159 Rewrite, Detail
  1175         &thm   & x  & x  &    &     & x  &rls  &    & x    &rls   &      &   \\
  1160 &thm & x & x & & & x &rls & & x &rls & & \\
  1176 Rewrite, Detail
  1161 Rewrite, Detail
  1177         &thm   & x  & x  &    &     & x  &Rrls &    & x    &Rrls  &      &   \\
  1162 &thm & x & x & & & x &Rrls & & x &Rrls & & \\
  1178 Rewrite\_Set,\_Inst
  1163 Rewrite\_Set,\_Inst
  1179         &rls   & x  & x  &    &     &    &     & x  & x    & x    &      &   \\
  1164 &rls & x & x & & & & & x & x & x & & \\
  1180 Calculate  
  1165 Calculate
  1181         &op    & x  & x  &    &     &    &     &    &      &      & x    &   \\
  1166 &op & x & x & & & & & & & & x & \\
  1182 Substitute 
  1167 Substitute
  1183         &subs  & x  &    &    & x   &    &     &    &      &      &      &   \\
  1168 &subs & x & & & x & & & & & & & \\
  1184         &      &    &    &    &     &    &     &    &      &      &      &   \\
  1169 & & & & & & & & & & & & \\
  1185 SubProblem 
  1170 SubProblem
  1186         &spec  & x  & x  &    & x   &    &     &    & x    & x    &      & x \\
  1171 &spec & x & x & & x & & & & x & x & & x \\
  1187         &fmz   &    &    &    &     &    &     &    &      &      &      &   \\
  1172 &fmz & & & & & & & & & & & \\
  1188 \hline
  1173 \hline
  1189 \end{tabular}\end{center}\end{table}
  1174 \end{tabular}\end{center}\end{table}}
  1190 }
  1175 
  1191 
  1176 
  1192 \section{\isac's theories}
  1177 \section{Die theories von \isac{}}
  1193 \isac's theories build upon Isabelles theories for high-order-logic (HOL) up to the respective development of real numbers ({\tt HOL/Real}). Theories have a special format defined in \cite{Isa-ref} and the suffix {\tt *.thy}; usually theories are paired with SML-files having the same filename and the suffix {\tt *.ML}.
  1178 Die theories von \isac{} basieren auf den theories f\"ur HOL und Real von Isabelle. Diese theories haben eine spezielle Form, die durch die Endung {\tt *.thy} definiert sind; normalerweise werden diese theories zusammen mit SML verwendet, und dann haben sie den selben Dateinamen, aber die Endung {\tt *.ML}.
  1194 
  1179 Die theories von \isac{} representieren den folgenden Teil vom Basiswissen von \isac{}, die Hierarchie von den zwei theories ist demnach strukturiert. Die {\tt *.ML} Dateien beinhalten {\em alle} Daten von den anderen zwei Hauptlinien des Basiswissens, die Probleme und die Methoden(ohne ihre jeweilige Struktur, die von den Problem Browsern und den Methode Browsern gemacht wird, zu pr\"asentieren.
  1195 \isac's theories represent the deductive part of \isac's knowledge base, the hierarchy of theories is structured accordingly. The {\tt *.ML}-files, however, contain {\em all} data of the other two axes of the knowledge base, the problems and the methods (without presenting their respective structure, which is done by the problem browser and the method browser, see \ref{pbt}).
  1180 Die Tab.\ref{theories} auf Seite \pageref{theories} listet die basis theories auf, die geplant sind in der Version \isac{} 1 angewendet zu werden. Wir erwarten, dass die Liste erweitert wird in n\"aherer Zukunft, und wir werden uns auch den theorie Browser genauer ansehen.
  1196 
  1181 Die ersten drei theories auf der Liste geh\"oren {\em nicht} zum Grundwissen von \isac{}; sie besch\"aftigen sich mit der Skriptsprache f\"ur Methoden und ist hier nur zur Vollst\"andigkeit angef\"uhrt.
  1197 Tab.\ref{theories} on p.\pageref{theories} lists the basic theories planned to be implemented in version \isac.1. We expext the list to be expanded in the near future, actually, have a look to the theory browser~!
  1182 
  1198 
       
  1199 The first three theories in the list do {\em not} belong to \isac's knowledge base; they are concerned with \isac's script-language for methods and listed here for completeness.
       
  1200 {\begin{table}[h]
  1183 {\begin{table}[h]
  1201 \caption{Theories in \isac-version I} \label{theories}
  1184 \caption{Theorien von der ersten Version von \isac} \label{theories}
  1202 %\tabcolsep=0.3mm
  1185 %\tabcolsep=0.3mm
  1203 \begin{center}
  1186 \begin{center}
  1204 \def\arraystretch{1.0}
  1187 \def\arraystretch{1.0}
  1205 \begin{tabular}{lp{9.0cm}}
  1188 \begin{tabular}{lp{9.0cm}}
  1206 theory & description \\
  1189 Theorie & Beschreibung \\
  1207 \hline
  1190 \hline
  1208 &\\
  1191 &\\
  1209 ListI.thy
  1192 ListI.thy
  1210 & assigns identifiers to the functions defined in {\tt Isabelle2002/src/HOL/List.thy} and (intermediatly~?) defines some more list functions\\
  1193 & ordnet die Bezeichnungen den Funktionen, die in {\tt Isabelle2002/src/HOL/List.thy} sind zu, und (intermediatly~?) definiert einige weitere Listen von Funktionen\\
  1211 ListI.ML
  1194 ListI.ML
  1212 & {\tt eval\_fn} for the additional list functions\\
  1195 & {\tt eval\_fn} f\"ur die zus\"atzliche Listen von Funktionen\\
  1213 Tools.thy
  1196 Tools.thy
  1214 & functions required for the evaluation of scripts\\
  1197 & Funktion, die f\"ur die Auswertung von Skripten ben\"otigt wird\\
  1215 Tools.ML
  1198 Tools.ML
  1216 & the respective {\tt eval\_fn}s\\
  1199 & bezieht sich auf {\tt eval\_fn}s\\
  1217 Script.thy
  1200 Script.thy
  1218 & prerequisites for scripts: types, tactics, tacticals,\\
  1201 & Vorraussetzung f\"ur Skripten: Typen, Taktiken, tacticals\\
  1219 Script.ML
  1202 Script.ML
  1220 & sets of tactics and functions for internal use\\
  1203 & eine Reihe von Taktiken und Funktionen f\"ur den internen Gebrauch\\
  1221 & \\
  1204 & \\
  1222 \hline
  1205 \hline
  1223 & \\
  1206 & \\
  1224 Typefix.thy
  1207 Typefix.thy
  1225 & an intermediate hack for escaping type errors\\
  1208 & fortgeschrittener Austritt, um den type Fehlern zu entkommen\\
  1226 Descript.thy
  1209 Descript.thy
  1227 & {\it description}s for the formulas in {\it model}s and {\it problem}s\\
  1210 & {\it Beschreibungen} f\"ur die Formeln von {\it Modellen} und {\it Problemen}\\
  1228 Atools
  1211 Atools
  1229 & (re-)definition of operators; general predicates and functions for preconditions; theorems for the {\tt eval\_rls}\\
  1212 & Neudefinierung von Operatoren; allgemeine Eigenschaften und Funktionen f\"ur Vorraussetzungen; Theorems f\"ur {\tt eval\_rls}\\
  1230 Float
  1213 Float
  1231 & floating point numerals\\
  1214 & Gleitkommerzahlendarstellung\\
  1232 Equation
  1215 Equation
  1233 & basic notions for equations and equational systems\\
  1216 & grunds\"atzliche Vorstellung f\"ur  Gleichungen und Gleichungssysteme\\
  1234 Poly
  1217 Poly
  1235 & polynomials\\
  1218 & Polynome\\
  1236 PolyEq
  1219 PolyEq
  1237 & polynomial equations and equational systems \\
  1220 & polynomiale Gleichungen und Gleichungssysteme \\
  1238 Rational.thy
  1221 Rational.thy
  1239 & additional theorems for rationals\\
  1222 & zus\"atzliche Theorems f\"ur Rationale Zahlen\\
  1240 Rational.ML
  1223 Rational.ML
  1241 & cancel, add and simplify rationals using (a generalization of) Euclids algorithm; respective reverse rulesets\\
  1224 & abbrechen, hinzuf\"ugen und vereinfachen von Rationalen Zahlen durch Verwenden von (einer allgemeineren Form von) Euclids Algorithmus; die entsprechenden umgekehrten Regels\"atze\\
  1242 RatEq
  1225 RatEq
  1243 & equations on rationals\\
  1226 & Gleichung mit rationalen Zahlen\\
  1244 Root
  1227 Root
  1245 & radicals; calculate normalform; respective reverse rulesets\\
  1228 & Radikanten; berechnen der Normalform; das betreffende umgekehrte Regelwerk\\
  1246 RootEq
  1229 RootEq
  1247 & equations on roots\\
  1230 & Gleichungen mit Wurzeln\\
  1248 RatRootEq
  1231 RatRootEq
  1249 & equations on rationals and roots (i.e. on terms containing both operations)\\
  1232 & Gleichungen mit rationalen Zahlen und Wurzeln (z.B. mit Termen, die beide Vorg\"ange enthalten)\\
  1250 Vect
  1233 Vect
  1251 & vector analysis\\
  1234 & Vektoren Analysis\\
  1252 Trig
  1235 Trig
  1253 & trigonometriy\\
  1236 & Trigonometrie\\
  1254 LogExp
  1237 LogExp
  1255 & logarithms and exponential functions\\
  1238 & Logarithmus und Exponentialfunktionen\\
  1256 Calculus
  1239 Calculus
  1257 & nonstandard analysis\\
  1240 & nicht der Norm entsprechende Analysis\\
  1258 Diff
  1241 Diff
  1259 & differentiation\\
  1242 & Differenzierung\\
  1260 DiffApp
  1243 DiffApp
  1261 & applications of differentiaten (maxima-minima-problems)\\
  1244 & Anwendungen beim Differenzieren (Maximum-Minimum-Probleme)\\
  1262 Test
  1245 Test
  1263 & (old) data for the test suite\\
  1246 & (alte) Daten f\"ur Testfolgen\\
  1264 Isac
  1247 Isac
  1265 & collects all \isac-theoris.\\
  1248 & enth\"alt alle Theorien von\isac{}\\
  1266 \end{tabular}\end{center}\end{table}
  1249 \end{tabular}\end{center}\end{table}}
  1267 }
  1250 
  1268 
  1251 
  1269 
  1252 \section{Daten in {\tt *.thy} und {\tt *.ML}}
  1270 \section{Data in {\tt *.thy}- and {\tt *.ML}-files}
  1253 Wie schon zuvor angesprochen, haben die arbeiten die theories von *.thy und *.ML zusamnmen und haben deswegen den selben Dateiname. Wie diese Daten zwischen den zwei Dateien verteilt werden wird in der
  1271 As already mentioned, theories come in pairs of {\tt *.thy}- and {\tt *.ML}-files with the same respective filename. How data are distributed between the two files is shown in Tab.\ref{thy-ML} on p.\pageref{thy-ML}.
  1254 Tab.\ref{thy-ML} auf Seite \pageref{thy-ML} gezeigt. Die Ordnung von den Dateinteilchen in den theories sollte an der Ordnung von der Liste festhalten.
       
  1255 
  1272 {\begin{table}[h]
  1256 {\begin{table}[h]
  1273 \caption{Data in {\tt *.thy}- and {\tt *.ML}-files} \label{thy-ML}
  1257 \caption{Daten in {\tt *.thy}- und {\tt *.ML}-files} \label{thy-ML}
  1274 \tabcolsep=2.0mm
  1258 \tabcolsep=2.0mm
  1275 \begin{center}
  1259 \begin{center}
  1276 \def\arraystretch{1.0}
  1260 \def\arraystretch{1.0}
  1277 \begin{tabular}{llp{7.7cm}}
  1261 \begin{tabular}{llp{7.7cm}}
  1278 file & data & description \\
  1262 Datei & Daten & Beschreibung \\
  1279 \hline
  1263 \hline
  1280 & &\\
  1264 & &\\
  1281 {\tt *.thy}
  1265 {\tt *.thy}
  1282 & consts 
  1266 & consts
  1283 & operators, predicates, functions, script-names ('{\tt Script} name \dots{\tt arguments}')
  1267 & Operatoren, Eigenschaften, Funktionen und Skriptnamen ('{\tt Skript} Name \dots{\tt Argumente}')
  1284 \\
  1268 \\
  1285 & rules  
  1269 & rules
  1286 & theorems: \isac{} uses Isabelles theorems if possible; additional theorems analoguous to such existing in Isabelle get the Isabelle-identifier attached an {\it I}
  1270 & theorems: \isac{} verwendet die Theorems von Isabelle, wenn m\"oglich; zus\"atzliche Theorems, die jenen von Isabelle entsprechen, bekommen ein {\it I} angeh\"angt
  1287 \\& &\\
  1271 \\& &\\
  1288 {\tt *.ML}
  1272 {\tt *.ML}
  1289 & {\tt theory' :=} 
  1273 & {\tt theory' :=}
  1290 & the theory defined by the actual {\tt *.thy}-file is made accessible to \isac
  1274 & Die Theorie, die 
       
  1275 abgegrenzt ist von der {\tt *.thy}-Datei, wird durch \isac{} zug\"anglich gemacht
  1291 \\
  1276 \\
  1292 & {\tt eval\_fn}
  1277 & {\tt eval\_fn}
  1293 & evaluation function for operators and predicates, coded on the meta-level (SML); the identifier of such a function is a combination of the keyword {\tt eval\_} with the identifier of the function as defined in {\tt *.thy}
  1278 & die Auswertungsfunktion f\"ur die Operatoren und Eigenschaften, kodiert im meta-Level (SML); die Bezeichnugn von so einer Funktion ist eine Kombination von Schl\"usselw\"ortern {\tt eval\_} und einer Bezeichnung von der Funktion, die in in {\tt *.thy} erkl\"art ist\\
  1294 \\
  1279 & {\tt *\_simplify}
  1295 & {\tt *\_simplify} 
  1280 & der automatisierte Vereinfacher f\"ur die tats\"achliche Theorie, z.B. die Bezeichnung von diesem Regelwerk ist eine Kombination aus den Theorienbezeichnungen und dem Schl\"usselwort {\tt *\_simplify}
  1296 & the canonical simplifier for the actual theory, i.e. the identifier for this ruleset is a combination of the theories identifier and the keyword {\tt *\_simplify}
       
  1297 \\
  1281 \\
  1298 & {\tt norm\_rls :=}
  1282 & {\tt norm\_rls :=}
  1299 & the canonical simplifier {\tt *\_simplify} is stored such that it is accessible for \isac
  1283 & der automatisierte Vereinfacherthe {\tt *\_simplify} wird so aufgehoben, dass er \"uber \isac zug\"anglich ist
  1300 \\
  1284 \\
  1301 & {\tt rew\_ord' :=}
  1285 & {\tt rew\_ord' :=}
  1302 & the same for rewrite orders, if needed outside of one particular ruleset
  1286 & das Gleiche f\"ur die Anordnung des Rewriting, wenn es ausserhalb eines speziellen Regelwerks gebraucht wird
  1303 \\
  1287 \\
  1304 & {\tt ruleset' :=}
  1288 & {\tt ruleset' :=}
  1305 & the same for rulesets (ordinary rulesets, reverse rulesets and {\tt eval\_rls})
  1289 & dasselbe wie f\"ur Regels\"atze (gew\"ohnliche Regels\"atze, umgekehrte Regels\"atze, und {\tt eval\_rls})
  1306 \\
  1290 \\
  1307 & {\tt calc\_list :=}
  1291 & {\tt calc\_list :=}
  1308 & the same for {\tt eval\_fn}s, if needed outside of one particular ruleset (e.g. for a tactic {\tt Calculate} in a script)
  1292 & dasselbe f\"ur {\tt eval\_fn}s, wenn es ausserhalb eines bestimmten Regelwerks gebraucht wird (wenn es ausserhalb eines bestimmten Regelwerks ben\"otigt wird) (z.B. f\"ur eine Taktik {\tt Calculate} in einem Skript)
  1309 \\
  1293 \\
  1310 & {\tt store\_pbl}
  1294 & {\tt store\_pbl}
  1311 & problems defined within this {\tt *.ML}-file are made accessible for \isac
  1295 & Probleme, die in {\tt *.ML}-Dateien definiert sind, werden zug\"anglich f\"ur \isac{}
  1312 \\
  1296 \\
  1313 & {\tt methods :=}
  1297 & {\tt methods :=}
  1314 & methods defined within this {\tt *.ML}-file are made accessible for \isac
  1298 & Methoden, die in {\tt *.ML}-Dateien definiert sind werden zug\"anglich f\"ur \isac{}
  1315 \\
  1299 \\
  1316 \end{tabular}\end{center}\end{table}
  1300 \end{tabular}\end{center}\end{table}}
  1317 }
  1301 
  1318 The order of the data-items within the theories should adhere to the order given in this list.
  1302 \section{Formale Beschreibung der Hierarchie von Problemen}
  1319 
  1303 
  1320 \section{Formal description of the problem-hierarchy}
  1304 \section{Skripttaktiken}
  1321 %for Richard Lang
  1305 Tats\"achlich sind es die Taktiken, die die Berechnungen vorantreiben: im Hintergrund bauen sie den ''Prooftree`` und sie \"ubernehmen die wichtigsten Aufgaben w\"ahrend der Auswertung bei der der ''script-interpreter`` zur Steuerung des Benutzers transferiert wird. Hier beschreiben wir nur den Syntax von den Taktiken; die Semantik ist beschrieben etwas weiter unten im Kontext mit den Taktiken, die die Benutzer/Innen dieses Programmes verwenden: da gibt es einen Schriftverkehr zwischen den Benutzer Taktiken und den Skripttaktiken.
  1322 
       
  1323 \section{Script tactics}
       
  1324 The tactics actually promote the calculation: they construct the prooftree behind the scenes, and they are the points during evaluation where the script-interpreter transfers control to the user. Here we only describe the sytax of the tactics; the semantics is described on p.\pageref{user-tactics} below in context with the tactics the student uses ('user-tactics'): there is a 1-to-1 correspondence between user-tactics and script-tactics.
       
  1325 
       
  1326 
       
  1327 
  1306 
  1328 
  1307 
  1329 
  1308 
  1330 \part{Authoring on the knowledge}
  1309 \part{Authoring on the knowledge}
  1331 
  1310