
ahirn@37877: \documentclass[11pt,a4paper,headline,headcount,towside,nocenter]{report}
ahirn@37877: \usepackage{latexsym} 
alexandra@37882: 
ahirn@37877: %\usepackage{ngerman}
ahirn@37877: %\grmn@dq@error ...and \dq \string #1 is undefined}
ahirn@37877: %l.989 ...tch the problem type \\{\tt["squareroot",
ahirn@37877: %                                                  "univ
ahirn@37877: \bibliographystyle{alpha}
ahirn@37877: 
ahirn@37877: \def\isac{${\cal I}\mkern-2mu{\cal S}\mkern-5mu{\cal AC}$}
neuper@37896: \def\sisac{{\footnotesize${\cal I}\mkern-2mu{\cal S}\mkern-5mu{\cal AC}$}}
ahirn@37877: 
neuper@37896: \title{\isac \\
neuper@37896:   Experimente zur Computermathematik\\[1.0ex]
neuper@37896:   und\\[1.0ex]
neuper@37896:   Handbuch f\"ur Autoren der\\
neuper@37896:   Mathematik-Wissensbasis\\[1.0ex]}
alexandra@37889: \author{Alexandra Hirn und Eva Rott\\
ahirn@37877:   \tt isac-users@ist.tugraz.at\\[1.0ex]}
ahirn@37877: \date{\today}
ahirn@37877: 
ahirn@37877: \begin{document}
ahirn@37877: \maketitle
ahirn@37877: \newpage
ahirn@37877: \tableofcontents
ahirn@37877: \newpage
ahirn@37877: \listoftables
ahirn@37877: \newpage
ahirn@37877: 
alexandra@37887: \chapter{Einleitung}
neuper@37896: Dies ist die \"Ubersetzung der dersten Kapitel einer englischen Version \footnote{http://www.ist.tugraz.at/projects/isac/publ/mat-eng.pdf}, auf den Stand von \sisac{} 2008 gebracht. Die \"Ubersetzung und Anpassung erfolgte durch die Autorinnen im Rahmen einer Ferialpraxis am Institut f\"ur Softwaretechnologie der TU Graz.
neuper@37896: 
neuper@37896: Diese Version zeichnet sich dadurch aus, dass sie von ``Nicht-Computer-Freaks''  f\"ur ``Nicht-Computer-Freaks'' geschrieben wurde.
neuper@37896: 
ahirn@37877: \section{``Authoring'' und ``Tutoring''}
alexandra@37891: \paragraph{TO DO} Mathematik lernen -- verschiedene Autoren -- Isabelle
ahirn@37877: Die Grundlage f\"ur \isac{} bildet Isabelle. Dies ist ein ``theorem prover'', der von L. Paulson und T. Nipkow entwickelt wird und Hard- und Software pr\"uft.
ahirn@37877: \section{Der Inhalt des Dokuments}
ahirn@37877: \paragraph{TO DO} {Als Anleitung:} Dieses Dokument beschreibt das Kerngebiet (KE) von \isac{}, das Gebiet der mathematics engine (ME) im Kerngebiet und die verschiedenen Funktionen wie das Umschreiben und der Vergleich.
ahirn@37877: 
alexandra@37891: \isac{} und KE wurden in SML geschrieben, die Sprache in Verbindung mit dem Vorg\"anger des theorem Provers Isabelle entwickelt. So kam es, dass in diesem Dokument die Ebene ASCII als SML Code pr\"asentiert wird. Der Leser wird vermutlich erkennen, dass der \isac{} Benutzer eine vollkommen andere Sichtweise auf eine grafische Benutzeroberfl\"ache bekommt.
ahirn@37877: 
alexandra@37891: Das Dokument ist eigenst\"andig; Basiswissen \"uber SML (f\"ur eine Einf\"uhrung siehe \cite{Paulson:91}), Terme und Umschreibung wird vorrausgesetzt.
ahirn@37877: 
ahirn@37877: %The interfaces will be moderately exended during the first phase of development of the mathematics knowledge. The work on the subprojects defined should {\em not} create interfaces of any interest to a user or another author of knowledge except identifiers (of type string) for theorems, rulesets etc.
ahirn@37877: 
ahirn@37877: Hinweis: SML Code, Verzeichnis, Dateien sind {\tt in 'tt' geschrieben}; besonders in {\tt ML>} ist das Kerngebiet schnell.
ahirn@37877: 
ahirn@37877: \paragraph{Versuchen Sie es!}  Ein weiteres Anliegen dieses Textes ist, dem Leser Tipps f\"ur Versuche mit den Anwendungen zu geben.
ahirn@37877: 
ahirn@37877: \section{Gleich am Computer ausprobieren!}\label{get-started}
alexandra@37891: \paragraph{TO DO screenshot} Bevor Sie mit Ihren Versuchen beginnen, m\"ochten wir Ihnen noch einige Hinweise geben:
ahirn@37877: \begin{itemize}
ahirn@37877:  \item System starten
ahirn@37877:  \item Shell aufmachen und die Datei mat-eng-de.sml \"offnen.
ahirn@37877:  \item $>$  :  Hinter diesem Zeichen (``Prompt'') stehen jene, die Sie selbst eingeben bzw. mit Copy und Paste aus der Datei kopieren.
ahirn@37877:  \item Die Eingabe wird mit ``;'' und ``Enter'' abgeschlossen.
ahirn@37877:  \item Zeilen, die nicht mit Prompt beginnen, werden vom Computer ausgegeben.
ahirn@37877:  
ahirn@37877: \end{itemize}
ahirn@37877: 
ahirn@37877: \part{Experimentelle Ann\"aherung}
ahirn@37877: 
ahirn@37877: \chapter{Terme und Theorien}
alexandra@37891: Wie bereits erw\"ahnt, geht es um Computer-Mathematik. In den letzten Jahren hat die ``computer science'' grosse Fortschritte darin gemacht, Mathematik auf dem Computer verst\"andlich darzustellen. Dies gilt f\"ur mathematische Formeln, f\"ur die Beschreibung von Problemen, f\"ur L\"osungsmethoden etc. Wir beginnen mit mathematischen Formeln.
ahirn@37877: 
ahirn@37877: \section{Von der Formel zum Term}
ahirn@37877: Um ein Beispiel zu nennen: Die Formel $a+b\cdot 3$ l\"asst sich in lesbarer Form so eingeben:
ahirn@37877: {\footnotesize\begin{verbatim}
alexandra@37891:    > "a + b * 3";
alexandra@37891:       val it = "a + b * 3" : string
ahirn@37877: \end{verbatim}}
alexandra@37892: \noindent ``a + b * 3'' ist also ein string (eine Zeichenfolge). In dieser Form weiss der Computer nicht, dass z.B. eine Multiplikation {\em vor} einer Addition zu rechnen ist. Isabelle braucht dazu eine andere Darstellung f\"ur Formeln. In diese kann man mit der Funktion {\tt str2term} (string to term) umrechnen:
ahirn@37877: {\footnotesize\begin{verbatim}
alexandra@37891:    > str2term "a + b * 3";
alexandra@37891:       val it =
alexandra@37891:          Const ("op +", "[RealDef.real, RealDef.real] => RealDef.real") $
alexandra@37891:                Free ("a", "RealDef.real") $
alexandra@37891:             (Const ("op *", "[RealDef.real, RealDef.real] => RealDef.real") $ ... $
alexandra@37891:                ...) : Term.term
ahirn@37877: \end{verbatim}}
alexandra@37892: \noindent Diese Form heisst {\tt term} und ist nicht f\"ur den Menschen zum lesen gedacht. Isabelle braucht sie aber intern zum Rechnen. Wir wollen sie mit Hilfe von {\tt val} (value) auf der Variable {\tt t} speichern:
ahirn@37877: {\footnotesize\begin{verbatim}
alexandra@37891:    > val t = str2term "a + b * 3";
alexandra@37891:       val t =  
alexandra@37891:          Const ("op +", "[RealDef.real, RealDef.real] => RealDef.real") $
alexandra@37891:                Free ("a", "RealDef.real") $
alexandra@37891:             (Const ("op *", "[RealDef.real, RealDef.real] => RealDef.real") $ ... $
alexandra@37891:                ...) : Term.term
neuper@37896: \end{verbatim}}
neuper@37896: Von dieser Variablen {\tt t} kann man den Wert jederzeit abrufen:
neuper@37896: {\footnotesize\begin{verbatim}
alexandra@37891:    > t;
alexandra@37891:       val it =
alexandra@37891:          Const ("op +", "[RealDef.real, RealDef.real] => RealDef.real") $
alexandra@37891:                Free ("a", "RealDef.real") $
alexandra@37891:             (Const ("op *", "[RealDef.real, RealDef.real] => RealDef.real") $ ... $
alexandra@37891:                ...) : Term.term
neuper@37896: \end{verbatim}}
alexandra@37892: Der auf {\tt t} gespeicherte Term kann einer Funktion {\tt atomty} \"ubergeben werden, die diesen in einer dritten Form zeigt:
ahirn@37877: {\footnotesize\begin{verbatim}
alexandra@37891:    > atomty term;
ahirn@37877:  
alexandra@37891:    ***
alexandra@37891:    *** Const (op +, [real, real] => real)
alexandra@37891:    *** . Free (a, real)
alexandra@37891:    *** . Const (op *, [real, real] => real)
alexandra@37891:    *** . . Free (b, real)
alexandra@37891:    *** . . Free (3, real)
alexandra@37891:    ***
ahirn@37877:  
alexandra@37891:    val it = () : unit
neuper@37896: \end{verbatim}}
alexandra@37891: Diese Darstellung nennt man ``abstract syntax'' und macht unmittelbar klar, dass man a und b nicht addieren kann, weil ein Mal vorhanden ist.
alexandra@37892: \newline Es gibt noch eine vierte Art von Term, den cterm. Er wird weiter unten verwendet, weil er sich als string lesbar darstellt.
ahirn@37877: 
ahirn@37877: \section{``Theory'' und ``Parsing``}
alexandra@37892: Der Unterschied zwischen \isac{} und bisheriger Mathematiksoftware (GeoGebra, Mathematica, Maple, Derive etc.) ist, dass das mathematische Wissen nicht im Programmcode steht, sondern in sogenannten theories (Theorien).
alexandra@37892: Dort wird das Mathematikwissen in einer f\"ur nicht Programmierer lesbaren Form geschrieben. Das Wissen von \isac{} ist in folgenden Theorien entahlten:
ahirn@37877: {\footnotesize\begin{verbatim}
alexandra@37891:    > Isac.thy;
alexandra@37891:       val it =
alexandra@37891:          {ProtoPure, CPure, HOL, Set, Typedef, Fun, Product_Type, Lfp, Gfp,
alexandra@37891:          Sum_Type, Relation, Record, Inductive, Transitive_Closure,
alexandra@37891:          Wellfounded_Recursion, NatDef, Nat, NatArith, Divides, Power,
alexandra@37891:          SetInterval, Finite_Set, Equiv, IntDef, Int, Datatype_Universe,
alexandra@37891:          Datatype, Numeral, Bin, IntArith, Wellfounded_Relations, Recdef, IntDiv,
alexandra@37891:          IntPower, NatBin, NatSimprocs, Relation_Power, PreList, List, Map,
alexandra@37891:          Hilbert_Choice, Main, Lubs, PNat, PRat, PReal, RealDef, RealOrd,
alexandra@37891:          RealInt, RealBin, RealArith0, RealArith, RComplete, RealAbs, RealPow,
alexandra@37891:          Ring_and_Field, Complex_Numbers, Real, ListG, Tools, Script, Typefix,
alexandra@37891:          Float, ComplexI, Descript, Atools, Simplify, Poly, Rational, PolyMinus,
alexandra@37891:          Equation, LinEq, Root, RootEq, RatEq, RootRat, RootRatEq, PolyEq, Vect,
alexandra@37891:          Calculus, Trig, LogExp, Diff, DiffApp, Integrate, EqSystem, Biegelinie,
alexandra@37891:          AlgEin, Test, Isac} : Theory.theory
neuper@37896: \end{verbatim}}
alexandra@37892: {\tt ProtoPure} und {\tt CPure} enthalten diese logischen Grundlagen, die in {\tt HOL} und den nachfolgenden Theorien erweitert werden. \isac{} als letzte Theorie beinhaltet das gesamte Wissen.
alexandra@37891: Dass das Mal vor dem Plus berechnet wird, ist so festgelegt:
neuper@37896: {\footnotesize\begin{verbatim}
alexandra@37892:    class plus =
alexandra@37892:    fixes plus :: "'a \<Rightarrow> 'a \<Rightarrow> 'a" (infixl "+" 65)
alexandra@37892: 
alexandra@37892:    class minus =
alexandra@37892:    fixes minus :: "'a \<Rightarrow> 'a \<Rightarrow> 'a" (infixl "-" 65)
alexandra@37892: 
alexandra@37892:    class uminus =
alexandra@37892:    fixes uminus :: "'a \<Rightarrow> 'a" ("- _" [81] 80)
alexandra@37892: 
alexandra@37892:    class times =
alexandra@37892:    fixes times :: "'a \<Rightarrow> 'a \<Rightarrow> 'a" (infixl "*" 70) 
neuper@37896: \end{verbatim}}
alexandra@37892: {\tt infix} gibt an, dass der Operator zwischen den Zahlen steht und nicht, wie in ''abstract syntax``, vorne oben.
alexandra@37892: Die Zahlen rechts davon legen die Priorit\"at fest. 70 f\"ur Mal ist gr\"osser als 65 f\"ur Plus und wird daher zuerst berechnet.
ahirn@37877: 
alexandra@37892: Wollen Sie wissen, wie die einzelnen Rechengesetze aussehen, k\"onnen Sie im Internet folgenden Link ansehen: http://isabelle.in.tum.de/dist/library/HOL/Groups.html
alexandra@37892: 
alexandra@37892: \paragraph{} Der Vorgang, bei dem aus einem {\tt string} ein Term entsteht, nennt man Parsing. Dazu wird Wissen aus der Theorie ben\"otigt, denn {\tt str2term} nimmt intern eine parse-Funktion, bei der immer das gesamte \isac{}-Wissen verwendet wird. Bei dieser Funktion wird weiters festgelegt, aus welcher Theorie das Wissen genommen werden soll.
neuper@37896: {\footnotesize\begin{verbatim}
alexandra@37892:    > parse Isac.thy "a + b";
alexandra@37892:       val it = Some "a + b" : Thm.cterm Library.option
neuper@37896: \end{verbatim}}
alexandra@37892: Um sich das Weiterrechnen zu erleichtern, kann das Ergebnis vom Parsing auf eine Variable, wie zum Beispiel {\tt t} gespeichert werden:
neuper@37896: {\footnotesize\begin{verbatim}
alexandra@37892:    > val t = parse Isac.thy "a + b";
alexandra@37892:       val t = Some "a + b" : Thm.cterm Library.option
neuper@37896: \end{verbatim}}
alexandra@37892: {\tt Some} bedeutet, dass das n\"otige Wissen vorhanden ist, um die Rechnung durchzuf\"uhren. {\tt None} zeigt uns, dass das Wissen fehlt oder ein Fehler aufgetreten ist. Daher sieht man im folgenden Beispiel, dass {\tt HOL.thy} nicht ausreichend Wissen enth\"alt:
neuper@37896: {\footnotesize\begin{verbatim}
alexandra@37892:    > parse HOL.thy "a + b";
alexandra@37892:       val it = None : Thm.cterm Library.option
neuper@37896: \end{verbatim}}
alexandra@37892: Anschliessend zeigen wir Ihnen noch ein zweites Beispiel, bei dem sowohl ein Fehler aufgetreten ist, als auch das Wissen fehlt:
neuper@37896: {\footnotesize\begin{verbatim}
alexandra@37892:    > parse Isac.thy "a + ";
alexandra@37892:       *** Inner syntax error: unexpected end of input
alexandra@37892:       *** Expected tokens: "contains_root" "is_root_free" "q_" "M_b" "M_b'"
alexandra@37892:       *** "Integral" "differentiate" "E_" "some_of" "||" "|||" "argument_in"
alexandra@37892:       *** "filter_sameFunId" "I__" "letpar" "Rewrite_Inst" "Rewrite_Set"
alexandra@37892:       *** "Rewrite_Set_Inst" "Check_elementwise" "Or_to_List" "While" "Script"
alexandra@37892:       *** "\\" "\\" "\\" "CHR" "xstr" "SOME" "\\" "@"
alexandra@37892:       *** "GREATEST" "[" "[]" "num" "\\" "{)" "{.." "\\" "(|"
alexandra@37892:       *** "\\" "SIGMA" "()" "\\" "PI" "\\" "\\" "{" "INT"
alexandra@37892:       *** "UN" "{}" "LEAST" "\\" "0" "1" "-" "!" "?" "?!" "\\"
alexandra@37892:       *** "\\" "\\" "\\!" "THE" "let" "case" "~" "if" "ALL"
alexandra@37892:       *** "EX" "EX!" "!!" "_" "\\" "\\" "PROP" "[|" "OFCLASS"
alexandra@37892:       *** "\\" "op" "\\" "%" "TYPE" "id" "longid" "var" "..."
alexandra@37892:       *** "\\" "("
alexandra@37892:       val it = None : Thm.cterm Library.option
neuper@37896: \end{verbatim}}
ahirn@37877: 
alexandra@37892: Das mathematische Wissen w\"achst mit jeder Theorie von ProtoPure bis Isac. In den folgenden Beispielen wird gezeigt, wie das Wissen w\"achst.
ahirn@37877: 
ahirn@37877: {\footnotesize\begin{verbatim}
ahirn@37877:    > (*-1-*);
ahirn@37877:    > parse HOL.thy "2^^^3";
ahirn@37877:       *** Inner lexical error at: "^^^3"
ahirn@37877:       val it = None : Thm.cterm Library.option         
neuper@37896: \end{verbatim}}
alexandra@37892: ''Inner lexical error`` und ''None`` bedeuten, dass ein Fehler aufgetreten ist, denn das Wissen \"uber {\tt *} findet sich erst in der {\tt theorie group}.
ahirn@37877: 
ahirn@37877: {\footnotesize\begin{verbatim}
ahirn@37877:    > (*-2-*);
ahirn@37877:    > parse HOL.thy "d_d x (a + x)";
ahirn@37877:       val it = None : Thm.cterm Library.option               
neuper@37896: \end{verbatim}}
alexandra@37891: Hier wiederum ist noch kein Wissen \"uber das Differenzieren vorhanden.
ahirn@37877: 
ahirn@37877: {\footnotesize\begin{verbatim}
ahirn@37877:    > (*-3-*);
ahirn@37877:    > parse Rational.thy "2^^^3";
ahirn@37877:       val it = Some "2 ^^^ 3" : Thm.cterm Library.option               
neuper@37896: \end{verbatim}}
ahirn@37877: 
ahirn@37877: {\footnotesize\begin{verbatim}
ahirn@37877:    > (*-4-*);
ahirn@37877:    > val Some t4 = parse Rational.thy "d_d x (a + x)";
ahirn@37877:       val t4 = "d_d x (a + x)" : Thm.cterm              
neuper@37896: \end{verbatim}}
ahirn@37877: 
ahirn@37877: {\footnotesize\begin{verbatim}
ahirn@37877:    > (*-5-*);
ahirn@37877:    > val Some t5 = parse Diff.thy  "d_d x (a + x)";
ahirn@37877:       val t5 = "d_d x (a + x)" : Thm.cterm             
neuper@37896: \end{verbatim}}
alexandra@37892: Die letzen drei Aufgaben k\"onnen schon gel\"ost werden, da {\tt Rational.thy} \"uber das n\"otige Wissen verf\"ugt.
ahirn@37877: 
ahirn@37877: \section{Details von Termen}
alexandra@37892: Mit Hilfe der darunterliegenden Darstellung sieht man, dass ein cterm in einen Term umgewandelt werden kann.
ahirn@37877: {\footnotesize\begin{verbatim}
ahirn@37877:    > term_of;
ahirn@37877:       val it = fn : Thm.cterm -> Term.term
neuper@37896: \end{verbatim}}
alexandra@37892: Durch die Umwandlung eines cterms in einen Term sieht man die einzelnen Teile des Terms. ''Free`` bedeutet, dass man die Variable \"andern kann.
ahirn@37877: {\footnotesize\begin{verbatim}
ahirn@37877:    > term_of t4;
ahirn@37877:       val it =
ahirn@37877:          Free ("d_d", "[RealDef.real, RealDef.real] => RealDef.real") $ ... $
ahirn@37877:          ...: Term.term
ahirn@37877: 
neuper@37896: \end{verbatim}}
alexandra@37891: In diesem Fall sagt uns das ''Const``, dass die Variable eine Konstante ist, also ein Fixwert, der immer die selbe Funktion hat.
ahirn@37877: {\footnotesize\begin{verbatim}
ahirn@37877:    > term_of t5;
ahirn@37877:       val it =
ahirn@37877:          Const ("Diff.d_d", "[RealDef.real, RealDef.real] => RealDef.real") $ ... $
ahirn@37877:          ... : Term.term
neuper@37896: \end{verbatim}}
alexandra@37891: Sollten verschiedene Teile des ''output`` (= das vom Computer Ausgegebene) nicht sichtbar sein, kann man mit einem bestimmten Befehl alles angezeigt werden.
ahirn@37877: {\footnotesize\begin{verbatim}
ahirn@37877:    > print_depth;
ahirn@37877:       val it = fn : int -> unit
neuper@37896:  \end{verbatim}}
alexandra@37892: Zuerst gibt man den Befehl ein, danach den Term, der gr\"osser werden soll. Dabei kann man selbst einen Wert f\"ur die L\"ange bestimmen.
ahirn@37877: {\footnotesize\begin{verbatim}
ahirn@37877:    > print_depth 10;
ahirn@37877:       val it = () : unit
ahirn@37877:    > term_of t4;
ahirn@37877:          val it =
ahirn@37877:             Free ("d_d", "[RealDef.real, RealDef.real] => RealDef.real") $
ahirn@37877:                 Free ("x", "RealDef.real") $
ahirn@37877:             (Const ("op +", "[RealDef.real, RealDef.real] => RealDef.real") $
ahirn@37877:                 Free ("a", "RealDef.real") $ Free ("x", "RealDef.real"))
ahirn@37877:          : Term.term
ahirn@37877: 
ahirn@37877:    > print_depth 10;
ahirn@37877:          val it = () : unit
ahirn@37877:    > term_of t5;
ahirn@37877:          val it =
ahirn@37877:             Const ("Diff.d_d", "[RealDef.real, RealDef.real] => RealDef.real") $
ahirn@37877:                 Free ("x", "RealDef.real") $
ahirn@37877:             (Const ("op +", "[RealDef.real, RealDef.real] => RealDef.real") $
ahirn@37877:                 Free ("a", "RealDef.real") $ Free ("x", "RealDef.real"))
ahirn@37877:          : Term.term
neuper@37896: \end{verbatim}}
alexandra@37891: \paragraph{Versuchen Sie es!}
ahirn@37877: Eine andere Variante um den Unterschied der beiden Terme zu sehen ist folgende: 
ahirn@37877: {\footnotesize\begin{verbatim}
ahirn@37877:    > (*-4-*) val thy = Rational.thy;
ahirn@37877:       val thy =
ahirn@37877:          {ProtoPure, CPure, HOL, Set, Typedef, Fun, Product_Type, Lfp, Gfp,
ahirn@37877:          Sum_Type, Relation, Record, Inductive, Transitive_Closure,
ahirn@37877:          Wellfounded_Recursion, NatDef, Nat, NatArith, Divides, Power,
ahirn@37877:          SetInterval, Finite_Set, Equiv, IntDef, Int, Datatype_Universe,
ahirn@37877:          Datatype, Numeral, Bin, IntArith, Wellfounded_Relations, Recdef, IntDiv,
ahirn@37877:          IntPower, NatBin, NatSimprocs, Relation_Power, PreList, List, Map,
ahirn@37877:          Hilbert_Choice, Main, Lubs, PNat, PRat, PReal, RealDef, RealOrd,
ahirn@37877:          RealInt, RealBin, RealArith0, RealArith, RComplete, RealAbs, RealPow,
ahirn@37877:          Ring_and_Field, Complex_Numbers, Real, ListG, Tools, Script, Typefix,
ahirn@37877:          Float, ComplexI, Descript, Atools, Simplify, Poly, Rational}
ahirn@37877:      : Theory.theory
ahirn@37877:    > ((atomty) o term_of o the o (parse thy)) "d_d x (a + x)";
ahirn@37877:  
ahirn@37877:       ***
ahirn@37877:       *** Free (d_d, [real, real] => real)
ahirn@37877:       *** . Free (x, real)
ahirn@37877:       *** . Const (op +, [real, real] => real)
ahirn@37877:       *** . . Free (a, real)
ahirn@37877:       *** . . Free (x, real)
ahirn@37877:       ***
ahirn@37877:  
ahirn@37877:       val it = () : unit
ahirn@37877: 
ahirn@37877: 
ahirn@37877:    > (*-5-*) val thy = Diff.thy;
ahirn@37877:       val thy =
ahirn@37877:          {ProtoPure, CPure, HOL, Set, Typedef, Fun, Product_Type, Lfp, Gfp,
ahirn@37877:          Sum_Type, Relation, Record, Inductive, Transitive_Closure,
ahirn@37877:          Wellfounded_Recursion, NatDef, Nat, NatArith, Divides, Power,
ahirn@37877:          SetInterval, Finite_Set, Equiv, IntDef, Int, Datatype_Universe,
ahirn@37877:          Datatype, Numeral, Bin, IntArith, Wellfounded_Relations, Recdef, IntDiv,
ahirn@37877:          IntPower, NatBin, NatSimprocs, Relation_Power, PreList, List, Map,
ahirn@37877:          Hilbert_Choice, Main, Lubs, PNat, PRat, PReal, RealDef, RealOrd,
ahirn@37877:          RealInt, RealBin, RealArith0, RealArith, RComplete, RealAbs, RealPow,
ahirn@37877:          Ring_and_Field, Complex_Numbers, Real, Calculus, Trig, ListG, Tools,
ahirn@37877:          Script, Typefix, Float, ComplexI, Descript, Atools, Simplify, Poly,
ahirn@37877:          Equation, LinEq, Root, RootEq, Rational, RatEq, RootRat, RootRatEq,
ahirn@37877:          PolyEq, LogExp, Diff} : Theory.theory
ahirn@37877:  
ahirn@37877:    > ((atomty) o term_of o the o (parse thy)) "d_d x (a + x)";
ahirn@37877:  
ahirn@37877:       ***
ahirn@37877:       *** Const (Diff.d_d, [real, real] => real)
ahirn@37877:       *** . Free (x, real)
ahirn@37877:       *** . Const (op +, [real, real] => real)
ahirn@37877:       *** . . Free (a, real)
ahirn@37877:       *** . . Free (x, real)
ahirn@37877:       ***
ahirn@37877:  
ahirn@37877:       val it = () : unit
neuper@37896: \end{verbatim}}
ahirn@37877: 
ahirn@37877: 
alexandra@37891: \chapter{''Rewriting``}
alexandra@37891: \section{Was ist Rewriting?}
alexandra@37891: Bei Rewriting handelt es sich um das Umformen von Termen nach vorgegebenen Regeln. Folgende zwei Funktionen sind notwendig:
neuper@37896: {\footnotesize\begin{verbatim}
alexandra@37892:    > rewrite;
alexandra@37892:       val it = fn
alexandra@37892:       :
alexandra@37892:       theory' ->
alexandra@37892:       rew_ord' ->
alexandra@37892:       rls' -> bool -> thm' -> cterm' -> (string * string list) Library.option
neuper@37896: \end{verbatim}}
alexandra@37892: Die Funktion hat zwei Argumente, die mitgeschickt werden m\"ussen, damit die Funktion arbeiten kann. Das letzte Element {\tt (cterm' * cterm' list) Library.option} im unteren Term ist das Ergebnis, das die Funktionen {\tt rewrite} zur\"uckgeben und die zwei vorhergehenden Argumente, {\tt theorem} und {\tt cterm}, sind die f\"ur uns wichtigen. {\tt Theorem} ist die Rechenregel und {\tt cterm} jene Formel auf die die Rechenregel angewendet wird.
neuper@37896: {\footnotesize\begin{verbatim}
alexandra@37892:    > rewrite_inst;
alexandra@37892:       val it = fn
alexandra@37892:       :
alexandra@37892:       theory' ->
alexandra@37892:       rew_ord' ->
alexandra@37892:       rls' ->bool -> 'a -> thm' -> cterm' -> (cterm' * cterm' list) Library.option
neuper@37896: \end{verbatim}}
alexandra@37892: Die Funktion {\tt rewrite\_inst} wird ben\"otigt, um Gleichungen, Rechnungen zum Differenzieren etc. zu l\"osen. Dabei wird die gebundene Variable (bdv) instanziiert, d.h. es wird die Variable angegeben, nach der man differenzieren will, bzw. f\"ur die ein Wert bei einer Gleichung herauskommen soll.
alexandra@37892: Um zu sehen wie der Computer vorgeht nehmen wir folgendes Beispiel, dessen Ergebnis offenbar 0 ist, was der Computer jedoch erst nach einer Reihe von Schritten herausfindet.
alexandra@37892: Im Beispiel wird differenziert, wobei \isac's Schreibweise jene von Computer Algebra Systemen (CAS) anzugleichen: in CAS wird differenziert mit $\frac{d}{dx}\; x^2 + 3 \cdot x + 4$, in \isac{} mit {\tt d\_d x (x \^{ }\^{ }\^{ } 2 + 3 * x + 4)}.
alexandra@37891: Zuerst werden die einzelnen Werte als Variablen gespeichert:
neuper@37896: {\footnotesize\begin{verbatim}
alexandra@37892:    > val thy' = "Diff.thy";
alexandra@37892:       val thy' = "Diff.thy" : string
alexandra@37892:    > val ro = "tless_true";
alexandra@37892:       val ro = "tless_true" : string
alexandra@37892:    > val er = "eval_rls";
alexandra@37892:       val er = "eval_rls" : string
alexandra@37892:    > val inst = [("bdv","x::real")];
alexandra@37892:       val inst = [("bdv", "x::real")] : (string * string) list
alexandra@37892:    > val ct = "d_d x (a + a * (2 + b))";
alexandra@37892:       val ct = "d_d x (a + a * (2 + b))" : string
neuper@37896: \end{verbatim}}
alexandra@37892: Nun wird die Rechnung nach den Regeln ausgerechnet, wobei am Ende mehrere Dinge zugleich gemacht werden.
alexandra@37892: Folgende Regeln werden ben\"otigt: Summenregel, Produktregel, Multiplikationsregel mit einem konstanten Faktor und zum Schluss die Additionsregel.
neuper@37896: {\footnotesize\begin{verbatim}
alexandra@37892:    > val Some (ct,_) = rewrite_inst thy' ro er true inst ("diff_sum","") ct;
alexandra@37892:       val ct = "d_d x a + d_d x (a * (2 + b))" : cterm'
alexandra@37892:    > val Some (ct,_) = rewrite_inst thy' ro er true inst ("diff_prod","") ct;
alexandra@37892:       val ct = "d_d x a + (d_d x a * (2 + b) + a * d_d x (2 + b))" : cterm'
alexandra@37892:    > val Some (ct,_) = rewrite_inst thy' ro er true inst ("diff_const","") ct;
alexandra@37892:       val ct = "d_d x a + (d_d x a * (2 + b) + a * 0) " : cterm'
alexandra@37892:    > val Some (ct,_) = rewrite_inst thy' ro er true inst ("diff_const","") ct;
alexandra@37892:       val ct = "d_d x a + (0 * (2 + b) + a * 0)" : cterm'
alexandra@37892:    > val Some (ct,_) = rewrite_inst thy' ro er true inst ("diff_const","") ct;
alexandra@37892:       val ct = "0 + (0 * (2 + b) + a * 0)" : cterm'
alexandra@37892:    > val Some (ct,_) = rewrite_set thy' true "make_polynomial" ct;
alexandra@37892:       val ct = "0" : string
neuper@37896: \end{verbatim}}
alexandra@37892: Was {\tt rewrite\_set} genau macht, finden Sie im n\"achsten Kapitel.
alexandra@37892: 
alexandra@37892: Dies w\"are ein etwas ernsthafteres Beispiel zum Differenzieren:
neuper@37896: {\footnotesize\begin{verbatim}
alexandra@37892:    > val ct = "d_d x (x ^^^ 2 + 3 * x + 4)";
alexandra@37892:    > val Some (ct,_) = rewrite_inst thy' ro er true inst ("diff_sum","") ct;
neuper@37896: \end{verbatim}}
neuper@37896: \paragraph{Versuchen Sie es,} diese Beispiel zu Ende zu f\"uhren! Die Regeln, die \isac{} kennt und zum Umformen verwenden kann, finden Sie im Internet \footnote{{\tiny\tt http://www.ist.tugraz.at/projects/isac/www/kbase/thy/browser\_info/HOL/HOL-Real/Isac/Diff.html}}.
alexandra@37891: 
neuper@37896: \section{Welche W\"unsche kann man an Rewriting stellen?}
alexandra@37891: Es gibt verschiedene Varianten von Rewriting, die alle eine bestimmte Bedeutung haben.
alexandra@37892: {\tt rewrite\_ set} wandelt Terme in ein ganzes rule set um, die normalerweise nur mit einem Theorem vereinfacht dargestellt werden.
alexandra@37891: Hierbei werden auch folgende Argumente verwendet:\\
alexandra@37891: \tabcolsep=4mm
alexandra@37891: \def\arraystretch{1.5}
alexandra@37891: \begin{tabular}{lp{11.0cm}}
alexandra@37892: {\tt theory} & Die Theory von Isabelle, die alle n\"otigen Informationen f\"ur das Parsing {\tt term} enth\"alt. \\
alexandra@37892: {\tt rew\_ord}& die Ordnung f\"ur das geordnete Rewriting. F\"ur {\em no} ben\"otigt das geordnete Rewriting {\tt tless\_true}, eine Ordnung, die f\"ur alle nachgiebigen Argumente true ist \\
alexandra@37891: {\tt rls} & Das rule set; zur Auswertung von bestimmten Bedingungen in {\tt thm} falls {\tt thm} eine conditional rule ist \\
alexandra@37892: {\tt bool} & ein Bitschalter, der die Berechnungen der m\"oglichen condition in {\tt thm} ausl\"ost: wenn sie {\tt false} ist, dann wird die condition bewertet und auf Grund des Resultats wendet man {\tt thm} an, oder nicht; wenn {\tt true} dann wird die condition nicht ausgewertet, aber man gibt sie in eine Menge von Hypothesen \\
alexandra@37891: {\tt thm} & das theorem versucht den {\tt term} zu \"uberschreiben \\
alexandra@37891: {\tt term} & {\tt thm} wendet Rewriting m\"oglicherweise auf den Term an \\
alexandra@37891: \end{tabular}\\
alexandra@37891: 
neuper@37896: {\footnotesize\begin{verbatim}
alexandra@37892:    > rewrite_set;
alexandra@37892:       val it = fn : theory' -> bool -> rls' -> ...
neuper@37896: \end{verbatim}}
neuper@37896: {\footnotesize\begin{verbatim}
alexandra@37892:    > rewrite_set_inst;
alexandra@37892:       val it = fn : theory' -> bool -> subs' -> .
neuper@37896: \end{verbatim}}
alexandra@37892: Wenn man sehen m\"ochte wie Rewriting bei den einzelnen theorems funktioniert kann man dies mit {\tt trace\_rewrite} versuchen.
neuper@37896: {\footnotesize\begin{verbatim}
alexandra@37892:    > trace_rewrite := true;
alexandra@37892:       val it = () : unit
neuper@37896: \end{verbatim}}
alexandra@37891: 
alexandra@37891: 
alexandra@37882: \section{Rule sets}
alexandra@37891: Einige der oben genannten Varianten von Rewriting beziehen sich nicht nur auf einen theorem, sondern auf einen ganzen Block von theorems, die man als rule set bezeichnet.
alexandra@37882: Dieser wird so lange angewendet, bis ein Element davon f\"ur Rewriting verwendet werden kann. Sollte der Begriff ''terminate`` fehlen, wird das Rule set nicht beendet und l\"auft weiter.
alexandra@37891: Ein Beispiel f\"ur einen rule set ist folgendes:
neuper@37896: {\footnotesize\begin{verbatim}
alexandra@37882: ???????????
neuper@37896: \end{verbatim}}
ahirn@37877: 
neuper@37896: {\footnotesize\begin{verbatim}
alexandra@37882:    > sym;
alexandra@37882:       val it = "?s = ?t ==> ?t = ?s" : Thm.thm
alexandra@37882:    > rearrange_assoc;
alexandra@37882:       val it =
alexandra@37882:          Rls
alexandra@37882:             {id = "rearrange_assoc",
alexandra@37882:                scr = Script (Free ("empty_script", "RealDef.real")),
alexandra@37882:                calc = [],
alexandra@37882:                erls =
alexandra@37882:                Rls
alexandra@37882:                   {id = "e_rls",
alexandra@37882:                      scr = EmptyScr,
alexandra@37882:                      calc = [],
alexandra@37882:                      erls = Erls,
alexandra@37882:                      srls = Erls,
alexandra@37882:                      rules = [],
alexandra@37882:                      rew_ord = ("dummy_ord", fn),
alexandra@37882:                      preconds = []},
alexandra@37882:                srls =
alexandra@37882:                Rls
alexandra@37882:                   {id = "e_rls",
alexandra@37882:                      scr = EmptyScr,
alexandra@37882:                      calc = [],
alexandra@37882:                      erls = Erls,
alexandra@37882:                      srls = Erls,
alexandra@37882:                      rules = [],
alexandra@37882:                      rew_ord = ("dummy_ord", fn),
alexandra@37882:                      preconds = []},
alexandra@37882:                rules =
alexandra@37882:                [Thm ("sym_radd_assoc", "?m1 + (?n1 + ?k1) = ?m1 + ?n1 + ?k1"  [.]),
alexandra@37882:                   Thm
alexandra@37882:                      ("sym_rmult_assoc",
alexandra@37882:                         "?m1 * (?n1 * ?k1) = ?m1 * ?n1 * ?k1"  [.])],
Walther@60509:                rew_ord = ("Rewrite_Ord.id_empty", fn),
alexandra@37882:                preconds = []} : rls
neuper@37896: \end{verbatim}}
ahirn@37877: 
ahirn@37877: 
alexandra@37882: \section{Berechnung von Konstanten}
alexandra@37882: Sobald Konstanten in dem Bereich des Subterms sind, k\"onnen sie von einer Funktion berechnet werden:
neuper@37896: {\footnotesize\begin{verbatim}
alexandra@37882:    > calculate;
alexandra@37882:       val it = fn
alexandra@37882:       :
alexandra@37882:          theory' ->
alexandra@37882:          string *
alexandra@37882:          (
alexandra@37882:          string ->
alexandra@37882:          Term.term -> Theory.theory -> (string * Term.term) Library.option) ->
alexandra@37882:          cterm' -> (string * thm') Library.option
ahirn@37877: 
alexandra@37882:    > calculate_;
alexandra@37882:       val it = fn
alexandra@37882:       :
alexandra@37882:          Theory.theory ->
alexandra@37882:          string *
alexandra@37882:          (
alexandra@37882:          string ->
alexandra@37882:          Term.term -> Theory.theory -> (string * Term.term) Library.option) ->
alexandra@37882:          Term.term -> (Term.term * (string * Thm.thm)) Library.option
neuper@37896: \end{verbatim}}
alexandra@37891: Man bekommt das Ergebnis und das theorem bezieht sich darauf. Daher sind die folgenden mathematischen Rechnungen m\"oglich:
neuper@37896: {\footnotesize\begin{verbatim}
alexandra@37882:    > calclist;
alexandra@37882:       val it =
alexandra@37882:          [("Vars", ("Tools.Vars", fn)), ("matches", ("Tools.matches", fn)),
alexandra@37882:             ("lhs", ("Tools.lhs", fn)), ("plus", ("op +", fn)),
alexandra@37882:             ("times", ("op *", fn)), ("divide_", ("HOL.divide", fn)),
alexandra@37882:             ("power_", ("Atools.pow", fn)), ("is_const", ("Atools.is'_const", fn)),
alexandra@37882:             ("le", ("op <", fn)), ("leq", ("op <=", fn)),
alexandra@37882:             ("ident", ("Atools.ident", fn)), ("sqrt", ("Root.sqrt", fn)),
alexandra@37882:             ("Test.is_root_free", ("is'_root'_free", fn)),
alexandra@37882:             ("Test.contains_root", ("contains'_root", fn))]
alexandra@37882:       :
alexandra@37882:          (
alexandra@37882:          string *
alexandra@37882:          (
alexandra@37882:          string *
alexandra@37882:          (
alexandra@37882:          string ->
alexandra@37882:          Term.term -> Theory.theory -> (string * Term.term) Library.option))) list
neuper@37896: \end{verbatim}}
alexandra@37891: 
ahirn@37877: 
ahirn@37877: 
ahirn@37877: 
alexandra@37882: \chapter{Termordnung}
alexandra@37891: Die Anordnungen der Begriffe sind unverzichtbar f\"ur den Gebrauch des Umschreibens von normalen Funktionen und von normalen Formeln, die n\"otig sind um passende Modelle f\"ur Probleme zu finden.
alexandra@37882: 
alexandra@37882: \section{Beispiel f\"ur Termordnungen}
alexandra@37891: Es ist nicht unbedeutend, eine Verbindung zu Termen herzustellen, die wirklich eine Ordnung besitzen. Diese Ordnungen sind selbstaufrufende Bahnordnungen:
alexandra@37882: 
alexandra@37882: {\footnotesize\begin{verbatim}
alexandra@37882:    > sqrt_right;
alexandra@37882:       val it = fn : bool -> Theory.theory -> subst -> Term.term * Term.term -> b       ool
alexandra@37882:    > tless_true;
alexandra@37882:       val it = fn : subst -> Term.term * Term.term -> bool
neuper@37896: \end{verbatim}}
alexandra@37882: 
alexandra@37891: Das ''bool`` Argument gibt Ihnen die M\"oglichkeit, die Kontrolle zu den zugeh\"origen Unterordunungen zur\"uck zu verfolgen, damit sich die Unterordnungen, die 'true' sind, als strings anzeigen lassen.
alexandra@37882: 
alexandra@37888: {\section{Geordnetes Rewriting}}
alexandra@37892: Beim Rewriting entstehen Probleme, die vom ''law of commutativity`` (= Kommutativgesetz) durch '+' und '*' verursacht werden. Diese Probleme k\"onnen nur durch geordnetes Rewriting gel\"ost werden, da hier ein Term nur umgeschrieben wird, wenn ein kleinerer dadurch entsteht.
alexandra@37888: 
alexandra@37888: 
alexandra@37891: \chapter{Problem hierachy}
alexandra@37888: \section{''Matching``}
alexandra@37891: Matching ist eine Technik von Rewriting, die von \isac{} verwendet wird, um ein Problem und den passenden problem type daf\"ur zu finden. Die folgende Funktion \"uberpr\"uft, ob Matching m\"oglich ist:
alexandra@37888: {\footnotesize\begin{verbatim}
alexandra@37888: > matches;
alexandra@37888: val it = fn : Theory.theory -> Term.term -> Term.term -> bool
neuper@37896: \end{verbatim}}
alexandra@37888: Die folgende Gleichung wird in Operatoren und freie Variablen zerlegt.
alexandra@37888: {\footnotesize\begin{verbatim}
alexandra@37888: > val t = (term_of o the o (parse thy)) "3 * x^^^2 = 1";
alexandra@37888: val t =
alexandra@37888: Const ("op =", "[RealDef.real, RealDef.real] => bool") $
alexandra@37888: (Const ("op *", "[RealDef.real, RealDef.real] => RealDef.real") $
alexandra@37888: Free ("3", "RealDef.real") $
alexandra@37888: (Const
alexandra@37888: ("Atools.pow",
alexandra@37888: "[RealDef.real, RealDef.real] => RealDef.real") $
alexandra@37888: Free ("x", "RealDef.real") $ Free ("2", " RealDef.real"))) $
alexandra@37888: Free ("1", "RealDef.real") : Term.term
neuper@37896: \end{verbatim}}
alexandra@37891: Nun wird ein Modell erstellt, das sich nicht auf bestimmte Zahlen bezieht, sondern nur eine generelle Zerlegung durchf\"uhrt.
alexandra@37888: {\footnotesize\begin{verbatim}
alexandra@37888: > val p = (term_of o the o (parse thy)) "a * b^^^2 = c";
alexandra@37888: val p =
alexandra@37888: Const ("op =", "[RealDef.real, RealDef.real] => bool") $
alexandra@37888: (Const ("op *", "[RealDef.real, RealDef.real] => RealDef.real") $
alexandra@37888: Free ("a", "RealDef.real") $
alexandra@37888: (Const
alexandra@37888: ("Atools.pow",
alexandra@37888: "[RealDef.real, RealDef.real] => RealDef.real") $
alexandra@37888: Free ("b", "RealDef.real") $ Free ("2", "RealDef.real"))) $
alexandra@37888: Free ("c", "RealDef.real") : Term.term
neuper@37896: \end{verbatim}}
alexandra@37891: Dieses Modell enth\"alt sogenannte \textit{scheme variables}.
alexandra@37888: {\footnotesize\begin{verbatim}
alexandra@37888: > atomt p;
alexandra@37888: "*** -------------"
alexandra@37888: "*** Const (op =)"
alexandra@37888: "*** . Const (op *)""*** . . Free (a, )"
alexandra@37888: "*** . . Const (Atools.pow)"
alexandra@37888: "*** . . . Free (b, )"
alexandra@37888: "*** . . . Free (2, )"
alexandra@37888: "*** . Free (c, )"
alexandra@37888: "\n"
alexandra@37888: val it = "\n" : string
neuper@37896: \end{verbatim}}
alexandra@37891: Das Modell wird durch den Befehl \textit{free2var} erstellt.
alexandra@37888: {\footnotesize\begin{verbatim}
alexandra@37888: > free2var;
alexandra@37888: val it = fn : Term.term -> Term.term
alexandra@37888: > val pat = free2var p;
alexandra@37888: val pat =
alexandra@37888: Const ("op =", "[RealDef.real, RealDef.real] => bool") $
alexandra@37888: (Const ("op *", "[RealDef.real, RealDef.real] => RealDef.real") $
alexandra@37888: Var (("a", 0), "RealDef.real") $
alexandra@37888: (Const
alexandra@37888: ("Atools.pow",
alexandra@37888: "[RealDef.real, RealDef.real] => RealDef.real") $
alexandra@37888: Var (("b", 0), "RealDef.real") $
alexandra@37888: Free ("2", "RealDef.real"))) $ Var (("c", 0), "RealDef.real")
alexandra@37888: : Term.term
alexandra@37888: > Sign.string_of_term (sign_of thy) pat;
alexandra@37888: val it = "?a * ?b ^^^ 2 = ?c" : string
neuper@37896: \end{verbatim}}
alexandra@37892: Durch \textit{atomt pat} wird der Term aufgespalten und in eine Form gebracht, die f\"ur die weiteren Schritte ben\"otigt wird.
alexandra@37888: {\footnotesize\begin{verbatim}
alexandra@37888: > atomt pat;
alexandra@37888: "*** -------------"
alexandra@37888: "*** Const (op =)"
alexandra@37888: "*** . Const (op *)"
alexandra@37888: "*** . . Var ((a, 0), )"
alexandra@37888: "*** . . Const (Atools.pow)"
alexandra@37888: "*** . . . Var ((b, 0), )"
alexandra@37888: "*** . . . Free (2, )"
alexandra@37888: "*** . Var ((c, 0), )"
alexandra@37888: "\n"
alexandra@37888: val it = "\n" : string
neuper@37896: \end{verbatim}}
alexandra@37891: Jetzt kann das Matching an den beiden vorigen Terme angewendet werden.
alexandra@37888: {\footnotesize\begin{verbatim}
alexandra@37888: > matches thy t pat;
alexandra@37888: val it = true : bool
alexandra@37888: > val t2 = (term_of o the o (parse thy)) "x^^^2 = 1";
alexandra@37888: val t2 =
alexandra@37888: Const ("op =", "[RealDef.real, RealDef.real] => bool") $
alexandra@37888: (Const
alexandra@37888: ("Atools.pow",
alexandra@37888: "[RealDef.real, RealDef.real] => RealDef.real") $
alexandra@37888: Free ("x", "RealDef.real") $ Free ("2", "RealDef.real")) $
alexandra@37888: Free ("1", "RealDef.real") : Term.term
alexandra@37888: > matches thy t2 pat;
alexandra@37888: val it = false : bool
alexandra@37888: > val pat2 = (term_of o the o (parse thy)) "?u^^^2 = ?v";
alexandra@37888: val pat2 =
alexandra@37888: Const ("op =", "[RealDef.real, RealDef.real] => bool") $
alexandra@37888: (Const
alexandra@37888: ("Atools.pow",
alexandra@37888: "[RealDef.real, RealDef.real] => RealDef.real") $
alexandra@37888: Var (("u", 0), "RealDef.real") $ Free ("2", "RealDef.real")) $
alexandra@37888: Var (("v", 0), "RealDef.real") : Term.term
alexandra@37888: > matches thy t2 pat2;
alexandra@37888: val it = true : bool
neuper@37896: \end{verbatim}}
alexandra@37888: 
alexandra@37891: \section{Zugriff auf die hierachy}
alexandra@37891: Man verwendet folgenden Befehl, um sich Zugang zur hierachy von problem type zu verschaffen.
alexandra@37888: {\footnotesize\begin{verbatim}
alexandra@37888: > show_ptyps;
alexandra@37888: val it = fn : unit -> unit
alexandra@37888: > show_ptyps();
alexandra@37888: [
alexandra@37888: ["e_pblID"],
alexandra@37888: ["simplification", "polynomial"],
alexandra@37888: ["simplification", "rational"],
alexandra@37888: ["vereinfachen", "polynom", "plus_minus"],
alexandra@37888: ["vereinfachen", "polynom", "klammer"],
alexandra@37888: ["vereinfachen", "polynom", "binom_klammer"],
alexandra@37888: ["probe", "polynom"],
alexandra@37888: ["probe", "bruch"],
alexandra@37888: ["equation", "univariate", "linear"],
alexandra@37888: ["equation", "univariate", "root", "sq", "rat"],
alexandra@37888: ["equation", "univariate", "root", "normalize"],
alexandra@37888: ["equation", "univariate", "rational"],
alexandra@37888: ["equation", "univariate", "polynomial", "degree_0"],
alexandra@37888: ["equation", "univariate", "polynomial", "degree_1"],
alexandra@37888: ["equation", "univariate", "polynomial", "degree_2", "sq_only"],
alexandra@37888: ["equation", "univariate", "polynomial", " 
alexandra@37888:  degree_2", "bdv_only"],
alexandra@37888: ["equation", "univariate", "polynomial", "degree_2", "pqFormula"],
alexandra@37888: ["equation", "univariate", "polynomial", "degree_2", "abcFormula"],
alexandra@37888: ["equation", "univariate", "polynomial", "degree_3"],
alexandra@37888: ["equation", "univariate", "polynomial", "degree_4"],
alexandra@37888: ["equation", "univariate", "polynomial", "normalize"],
alexandra@37888: ["equation", "univariate", "expanded", "degree_2"],
alexandra@37888: ["equation", "makeFunctionTo"],
alexandra@37888: ["function", "derivative_of", "named"],
alexandra@37888: ["function", "maximum_of", "on_interval"],
alexandra@37888: ["function", "make", "by_explicit"],
alexandra@37888: ["function", "make", "by_new_variable"],
alexandra@37888: ["function", "integrate", "named"],
alexandra@37888: ["tool", "find_values"],
alexandra@37888: ["system", "linear", "2x2", "triangular"],
alexandra@37888: ["system", "linear", "2x2", "normalize"],
alexandra@37888: ["system", "linear", "3x3"],
alexandra@37888: ["system", "linear", "4x4", "triangular"],
alexandra@37888: ["system", "linear", "4x4", "normalize"],
alexandra@37888: ["Biegelinien", "
alexandra@37888: MomentBestimmte"],
alexandra@37888: ["Biegelinien", "MomentGegebene"],
alexandra@37888: ["Biegelinien", "einfache"],
alexandra@37888: ["Biegelinien", "QuerkraftUndMomentBestimmte"],
alexandra@37888: ["Biegelinien", "vonBelastungZu"],
alexandra@37888: ["Biegelinien", "setzeRandbedingungen"],
alexandra@37888: ["Berechnung", "numerischSymbolische"],
alexandra@37888: ["test", "equation", "univariate", "linear"],
alexandra@37888: ["test", "equation", "univariate", "plain_square"],
alexandra@37888: ["test", "equation", "univariate", "polynomial", "degree_two", "pq_formula"],
alexandra@37888: ["test", "equation", "univariate", "polynomial", "degree_two", "abc_formula"],
alexandra@37888: ["test", "equation", "univariate", "squareroot"],
alexandra@37888: ["test", "equation", "univariate", "normalize"],
alexandra@37888: ["test", "equation", "univariate", "sqroot-test"]
alexandra@37888: ]
alexandra@37888: val it = () : unit
neuper@37896: \end{verbatim}}
alexandra@37888: 
alexandra@37891: \section{Die passende ''formalization`` f\"ur den problem type}
alexandra@37891: Eine andere Art des Matching ist es die richtige ''formalization`` zum jeweiligen problem type zu finden. Wenn eine solche vorhanden ist, kann \isac{} selbstst\"andig die Probleme l\"osen.
alexandra@37888: 
alexandra@37891: \section{''problem-refinement``}
alexandra@37891: Will man die problem hierachy (= ) aufstellen, so ist darauf zu achten, dass man die verschiedenen Branches so konstruiert, dass das problem-refinement automatisch durchgef\"uhrt werden kann.
alexandra@37888: {\footnotesize\begin{verbatim}
alexandra@37888: > refine;
alexandra@37888: val it = fn : fmz_ -> pblID -> SpecifyTools.match list
alexandra@37888: > val fmz = ["equality (sqrt(9 + 4 * x)=sqrt x 
alexandra@37888: + sqrt (5 + x))",
alexandra@37888: # "soleFor x","errorBound (eps=0)",
alexandra@37888: # "solutions L"];
alexandra@37888: val fmz =
alexandra@37888: ["equality (sqrt(9 + 4 * x)=sqrt x + sqrt (5 + x))", "soleFor x",
alexandra@37888: "errorBound (eps=0)", ...] : string list
alexandra@37888: > refine fmz ["univariate","equation"];
alexandra@37888: *** pass ["equation","univariate"]
alexandra@37888: *** comp_dts: ??.empty $ soleFor x
alexandra@37888: Exception- ERROR raised
neuper@37896: \end{verbatim}}
alexandra@37891: Wenn die ersten zwei Regeln nicht angewendet werden k\"onnen, kommt die dritte zum Einsatz:
alexandra@37888: {\footnotesize\begin{verbatim}
alexandra@37888: > val fmz = ["equality (x + 1 = 2)",
alexandra@37888: # "solveFor x","errorBound (eps=0)",
alexandra@37888: # "solutions L"];
alexandra@37888: val fmz = ["equality (x + 1 = 2)", "solveFor x", "errorBound (eps=0)", ...]
alexandra@37888: : string list
alexandra@37888: > refine fmz ["univariate","equation"];
alexandra@37888: *** pass ["equation","univariate"]
alexandra@37888: *** pass ["equation","univariate","linear"]
alexandra@37888: *** pass ["equation","univariate","root"]
alexandra@37888: *** pass ["equation","univariate","rational"]
alexandra@37888: *** pass ["equation","univariate","polynomial" ]
alexandra@37888: *** pass ["equation","univariate","polynomial","degree_0"]
alexandra@37888: *** pass ["equation","univariate","polynomial","degree_1"]
alexandra@37888: *** pass ["equation","univariate","polynomial","degree_2"]
alexandra@37888: *** pass ["equation","univariate","polynomial","degree_3"]
alexandra@37888: *** pass ["equation","univariate","polynomial","degree_4"]
alexandra@37888: *** pass ["equation","univariate","polynomial","normalize"]
alexandra@37888: val it =
alexandra@37888: [Matches
alexandra@37888: (["univariate", "equation"],
alexandra@37888: {Find = [Correct "solutions L"], With = [...], ...}),
alexandra@37888: NoMatch (["linear", "univariate", ...], {Find = [...], ...}),
alexandra@37888: NoMatch (["root", ...], ...), ...] : SpecifyTools.match list
neuper@37896: \end{verbatim}}
alexandra@37891: Der problem type wandelt $x + 1 = 2$ in die normale Form $-1 + x = 0$ um. Diese Suche nach der jeweiligen problem hierachy kann mit Hilfe eines ''proof state`` durchgef\"uhrt werden (siehe n\"achstes Kapitel).
alexandra@37882: 
alexandra@37887: 
alexandra@37891: \chapter{''Methods``}
alexandra@37891: Methods werden dazu verwendet, Probleme von type zu l\"osen. Sie sind in einer anderen Programmiersprache beschrieben. Die Sprache sieht einfach aus, betreibt aber im Hintergrund einen enormen Pr\"ufaufwand. So muss sich der Programmierer nicht mit technischen Details befassen, gleichzeitig k\"onnen aber auch keine falschen Anweisungen eingegeben werden.
alexandra@37891: \section{Der ''Syntax`` des script}
alexandra@37882: Syntax beschreibt den Zusammenhang der einzelnen Zeichen und Zeichenfolgen mit den Theorien.
alexandra@37882: Er kann so definiert werden:
alexandra@37882: \begin{tabbing}
alexandra@37882: 123\=123\=expr ::=\=$|\;\;$\=\kill
alexandra@37882: \>script ::= {\tt Script} id arg$\,^*$ = body\\
alexandra@37882: \>\>arg ::= id $\;|\;\;($ ( id :: type ) $)$\\
alexandra@37882: \>\>body ::= expr\\
alexandra@37882: \>\>expr ::= \>\>{\tt let} id = expr $($ ; id = expr$)^*$ {\tt in} expr\\
alexandra@37882: \>\>\>$|\;$\>{\tt if} prop {\tt then} expr {\tt else} expr\\
alexandra@37882: \>\>\>$|\;$\>listexpr\\
alexandra@37882: \>\>\>$|\;$\>id\\
alexandra@37882: \>\>\>$|\;$\>seqex id\\
alexandra@37882: \>\>seqex ::= \>\>{\tt While} prop {\tt Do} seqex\\
alexandra@37882: \>\>\>$|\;$\>{\tt Repeat} seqex\\
alexandra@37882: \>\>\>$|\;$\>{\tt Try} seqex\\
alexandra@37882: \>\>\>$|\;$\>seqex {\tt Or} seqex\\
alexandra@37882: \>\>\>$|\;$\>seqex {\tt @@} seqex\\
alexandra@37882: \>\>\>$|\;$\>tac $($ id $|$ listexpr $)^*$\\
alexandra@37882: \>\>type ::= id\\
alexandra@37882: \>\>tac ::= id
neuper@37896: \end{tabbing}
ahirn@37877: 
alexandra@37887: \section{\"Uberpr\"ufung der Auswertung}
alexandra@37887: Das Kontrollsystem arbeitet mit den folgenden Script-Ausdr\"ucken, die {\it tacticals} genannt werden:
alexandra@37887: \begin{description}
alexandra@37887: \item{{\tt while} prop {\tt Do} expr id} 
alexandra@37887: \item{{\tt if} prop {\tt then} expr {\tt else} expr}
alexandra@37887: \end{description}
alexandra@37891: W\"ahrend die genannten Befehle das Kontrollsystem durch Auswertung der Formeln ausl\"osen, h\"angen die anderen von der Anwendbarkeit der Formel in den entsprechenden Unterbegriffen ab:
alexandra@37887: \begin{description}
alexandra@37887: \item{{\tt Repeat} expr id}
alexandra@37887: \item{{\tt Try} expr id}
alexandra@37887: \item{expr {\tt Or} expr id}
alexandra@37887: \item{expr {\tt @@} expr id}
alexandra@37887: \item xxx
alexandra@37887: \end{description}
alexandra@37887: 
alexandra@37887: 
alexandra@37888: 
alexandra@37888: \chapter{Befehle von \isac{}}
alexandra@37889: 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.\
alexandra@37891: \newline\linebreak \textbf{Init\_Proof\_Hid (dialogmode, formalization, specifictaion)} gibt die eingegebenen Befehle an die mathematic engine weiter, wobei die beiden letzten Begriffe die Beispiele automatisch speichern. Es ist nicht vorgesehen, dass der Sch\"uler tactic verwendet.\
alexandra@37891: \newline\linebreak \textbf{Init\_Proof} bildet mit einem ''proof tree`` ein leeres Modell.\
alexandra@37891: \newline\linebreak \textbf{Model\_Problem problem} bestimmt ein problemtype, das wom\"oglich in der ''hierachy`` gefunden wurde, und verwendet es f\"ur das Umformen.\
alexandra@37891: \newline\linebreak \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.\
alexandra@37891: \newline\linebreak \textbf{Specify\_Theorie theory, Specify\_Problem proble, Specify\_Method method} gibt das entsprechende Element des Basiswissens an.\
alexandra@37891: \newline\linebreak \textbf{Refine\_Problem problem} sucht nach einem Problem in der hierachy, das auf das vorhandene zutrifft.\
alexandra@37891: \newline\linebreak \textbf{Apply\_Method method} beendet das Modell und die Beschreibung. Danach wird die L\"osungmeldung ge\"offnet.\
alexandra@37891: \newline\linebreak \textbf{Free\_Solve} beginnt eine L\"osungsmeldung ohne die Hilfe einer method.\
alexandra@37891: \newline\linebreak \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``.\
alexandra@37891: \newline\linebreak \textbf{Rewrite\_Asm theorem} hat die gleiche Funktion wie Rewrite, speichert jedoch eine endg\"ultige Vorraussetzung des theorems, anstatt diese zu sch\"atzen.\
alexandra@37891: \newline\linebreak \textbf{Rewrite\_Set ruleset} hat \"ahnliche Funktionen wie Rewrite, gilt aber f\"ur einen ganzen Satz von theorems, dem rule set.\
alexandra@37891: \newline\linebreak \textbf{Rewrite\_Inst (substitution, theorem), Rewrite\_Set\_Inst (substitution, rule set)} ist vergleichbar mit besonderen tactics, ersetzt aber Konstanten im theorem, bevor es zu einer Anwendung kommt.\
alexandra@37891: \newline\linebreak \textbf{Calculate operation} berechnet das Ergebnis der Eingabe mit der aktuellen Formel (plus, minus, times, cancel, pow, sqrt).\
alexandra@37891: \newline\linebreak \textbf{Substitute substitution} f\"ugt der momentanen Formel {\tt substitution} hinzu und wandelt es um.\
alexandra@37891: \newline\linebreak \textbf{Take formula} startet eine neue Reihe von Rechnungen in den Formeln, wo sich schon eine andere Rechnung befindet.\
alexandra@37891: \newline\linebreak \textbf{Subproblem (theory, problem)} beginnt ein subproblem innerhalb einer Rechnung.\
alexandra@37891: \newline\linebreak \textbf{Function formula} ruft eine Funktion auf, in der der Name in der Formel enthalten ist. ???????\
alexandra@37891: \newline\linebreak \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.\
alexandra@37891: \newline\linebreak \textbf{Check\_elementwise assumption} wird in Bezug auf die aktuelle Formel verwendet, die Elemente in einer Liste enth\"alt.\
alexandra@37891: \newline\linebreak \textbf{Or\_to\_List} wandelt eine Verbindung von Gleichungen in eine Liste von Gleichungen um.\
alexandra@37891: \newline\linebreak \textbf{Check\_postcond} \"uberpr\"uft die momentane Formel im Bezug auf die Nachbedinung beim Beenden des subproblem.\
alexandra@37891: \newline\linebreak \textbf{End\_Proof} beendet eine \"Uberpr\"ufung und gibt erst dann ein Ergebnis aus, wenn Check\_postcond erfolgreich abgeschlossen wurde.
alexandra@37888: 
alexandra@37889: \section{Die Funktionsweise der mathematic engine}
alexandra@37891: Ein proof (= Beweis) wird in der mathematic engine me von der tactic {\tt Init\_Proof} gestartet und wird wechselwirkend mit anderen tactics vorangebracht. Auf den input (= das, was eingegeben wurde) einzelner tactics folgt eine Formel, die von der me ausgegeben wird, und die darauf folgende tactic gilt. Der proof ist beendet, sobald die me {\tt End\_Proof} als n\"achste tactic vorschl\"agt.
alexandra@37889: \newline Im Anschluss werden Sie einen Rechenbeweis sehen, der von der L\"osung einer Gleichung (= equation) handelt, bei der diese automatisch differenziert wird. 
alexandra@37889: {\footnotesize\begin{verbatim}
alexandra@37889: ??????????????????????????????????????????????????????????????????????????????????   
alexandra@37888: 
alexandra@37889: ML> val fmz = ["equality ((x+#1)*(x+#2)=x^^^#2+#8)","solveFor x",
ahirn@37877:                   "errorBound (eps=#0)","solutions L"];
ahirn@37877:    val fmz =
ahirn@37877:      ["equality ((x+#1)*(x+#2)=x^^^#2+#8)","solveFor x","errorBound (eps=#0)",
ahirn@37877:       "solutions L"] : string list
ahirn@37877:    ML>
ahirn@37877:    ML> val spec as (dom, pbt, met) = ("SqRoot.thy",["univariate","equation"],
ahirn@37877:                                  ("SqRoot.thy","no_met"));
ahirn@37877:    val dom = "SqRoot.thy" : string
ahirn@37877:    val pbt = ["univariate","equation"] : string list
ahirn@37877:    val met = ("SqRoot.thy","no_met") : string * string
neuper@37896: \end{verbatim}}
ahirn@37877: 
alexandra@37889: \section{Der Beginn einer Rechnung}
alexandra@37891: 
alexandra@37891: 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. Um einen neuen proof beginnen zu k\"onnen, werden folgende Schritte durchgef\"uhrt:
neuper@37896: {\footnotesize\begin{verbatim}
alexandra@37889: ???????????????????????????????????????????????????????????????????????????????????????????? 
alexandra@37889: ML>  val (mID,m) = ("Init_Proof",Init_Proof (fmz, (dom,pbt,met)));
ahirn@37877:    val mID = "Init_Proof" : string
ahirn@37877:    val m =
ahirn@37877:      Init_Proof
ahirn@37877:        (["equality ((x+#1)*(x+#2)=x^^^#2+#8)","solveFor x","errorBound (eps=#0)",
ahirn@37877:          "solutions L"],("SqRoot.thy",[#,#],(#,#))) : mstep
ahirn@37877:    ML>
ahirn@37877:    ML>  val (p,_,f,nxt,_,pt) = me (mID,m) e_pos' c EmptyPtree;
ahirn@37877:    val p = ([],Pbl) : pos'
ahirn@37877:    val f = Form' (PpcKF (0,EdUndef,0,Nundef,(#,#))) : mout
ahirn@37877:    val nxt = ("Refine_Tacitly",Refine_Tacitly ["univariate","equation"])
ahirn@37877:      : string * mstep
ahirn@37877:    val pt =
ahirn@37877:      Nd
ahirn@37877:        (PblObj
ahirn@37877:           {branch=#,cell=#,env=#,loc=#,meth=#,model=#,origin=#,ostate=#,probl=#,
wneuper@59279:            result=#,spec=#},[]) : ctree
neuper@37896: \end{verbatim}}
alexandra@37891: Die mathematics engine gibt etwas mit dem type {\tt mout} aus, was in unserem Fall ein Problem darstellt. Sobald mehr angezeigt wird, m\"usste dieses jedoch gel\"ost sein.
neuper@37896: {\footnotesize\begin{verbatim}
alexandra@37889: ?????????????????????????????????????????????????????????????????????????????????????????????
ahirn@37877:    ML> Compiler.Control.Print.printDepth:=8; (*4 default*)
ahirn@37877:    val it = () : unit
ahirn@37877:    ML>
ahirn@37877:    ML> f;
ahirn@37877:    val it =
ahirn@37877:      Form'
ahirn@37877:        (PpcKF
ahirn@37877:           (0,EdUndef,0,Nundef,
ahirn@37877:            (Problem [],
ahirn@37877:             {Find=[Incompl "solutions []"],
ahirn@37877:              Given=[Incompl "equality",Incompl "solveFor"],Relate=[],
ahirn@37877:              Where=[False "matches (?a = ?b) e_"],With=[]}))) : mout
neuper@37896: \end{verbatim}}
ahirn@37877: {\footnotesize\begin{verbatim}
alexandra@37889: ?????????????????????????????????????????????????????????????????????????????????????????????
ahirn@37877:    ML>  nxt;
ahirn@37877:    val it = ("Refine_Tacitly",Refine_Tacitly ["univariate","equation"])
ahirn@37877:      : string * mstep
ahirn@37877:    ML>
ahirn@37877:    ML>  val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
ahirn@37877:    val nxt = ("Model_Problem",Model_Problem ["normalize","univariate","equation"])
ahirn@37877:      : string * mstep
ahirn@37877:    ML>
ahirn@37877:    ML>  val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
neuper@37896: \end{verbatim}}
ahirn@37877: 
alexandra@37889: \section{The phase of modeling}
alexandra@37891: Dieses Kapitel besch\"aftigt sich mit dem input der Einzelheiten bei einem Problem. Die me kann dabei helfen, wenn man die formalization durch {\tt Init\_Proof} darauf hinweist. Normalerweise weiss die mathematics engine die n\"achste gute tactic.
ahirn@37877: {\footnotesize\begin{verbatim}
alexandra@37889: ?????????????????????????????????????????????????????????????????????????????????????????????
ahirn@37877:    ML>  nxt;
ahirn@37877:    val it =
ahirn@37877:      ("Add_Given",Add_Given "equality ((x + #1) * (x + #2) = x ^^^ #2 + #8)")
ahirn@37877:      : string * mstep
ahirn@37877:    ML>
ahirn@37877:    ML>  val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
ahirn@37877:    val nxt = ("Add_Given",Add_Given "solveFor x") : string * mstep
ahirn@37877:    ML>
ahirn@37877:    ML>  val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
ahirn@37877:    val nxt = ("Add_Find",Add_Find "solutions L") : string * mstep
ahirn@37877:    ML>
ahirn@37877:    ML>  val (p,_,f,nxt,_,pt) = me nxt p [1] pt; 
ahirn@37877:    val f = Form' (PpcKF (0,EdUndef,0,Nundef,(#,#))) : mout
neuper@37896: \end{verbatim}}
ahirn@37877: {\footnotesize\begin{verbatim}
alexandra@37889: ?????????????????????????????????????????????????????????????????????????????????????????????
ahirn@37877:    ML>  Compiler.Control.Print.printDepth:=8;
ahirn@37877:    ML>  f;
ahirn@37877:    val it =
ahirn@37877:      Form'
ahirn@37877:        (PpcKF
ahirn@37877:           (0,EdUndef,0,Nundef,
ahirn@37877:            (Problem [],
ahirn@37877:             {Find=[Correct "solutions L"],
ahirn@37877:              Given=[Correct "equality ((x + #1) * (x + #2) = x ^^^ #2 + #8)",
ahirn@37877:                     Correct "solveFor x"],Relate=[],Where=[],With=[]}))) : mout
neuper@37896: \end{verbatim}}
ahirn@37877: 
alexandra@37889: 
alexandra@37889: \section{The phase of specification}
alexandra@37891: Diese phase liefert eindeutige Bestimmungen einer domain, 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.
ahirn@37877: {\footnotesize\begin{verbatim}
alexandra@37889: ??????????????????????????????????????????????????????????????????????????????????????????
alexandra@37889:    ML> nxt;
ahirn@37877:    val it = ("Specify_Domain",Specify_Domain "SqRoot.thy") : string * mstep
ahirn@37877:    ML>
ahirn@37877:    ML> val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
ahirn@37877:    val nxt =
ahirn@37877:      ("Specify_Problem",Specify_Problem ["normalize","univariate","equation"])
ahirn@37877:      : string * mstep
ahirn@37877:    val pt =
ahirn@37877:      Nd
ahirn@37877:        (PblObj
ahirn@37877:           {branch=#,cell=#,env=#,loc=#,meth=#,model=#,origin=#,ostate=#,probl=#,
wneuper@59279:               result=#,spec=#},[]) : ctree
neuper@37896: \end{verbatim}}
alexandra@37891: Die me erkennt den richtigen Problem type und arbeitet so weiter:
ahirn@37877: {\footnotesize\begin{verbatim}
alexandra@37889: ?????????????????????????????????????????????????????????????????????????????????????????
ahirn@37877:    ML> val nxt = ("Specify_Problem",
ahirn@37877:                Specify_Problem ["polynomial","univariate","equation"]);
ahirn@37877:    ML> val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
ahirn@37877:    val f = Form' (PpcKF (0,EdUndef,0,Nundef,(#,#))) : mout
ahirn@37877:    val nxt =
ahirn@37877:      ("Refine_Problem",Refine_Problem ["normalize","univariate","equation"])
ahirn@37877:      : string * mstep
ahirn@37877:    ML>
ahirn@37877:    ML> val nxt = ("Specify_Problem",
ahirn@37877:                Specify_Problem ["linear","univariate","equation"]);
ahirn@37877:    ML> val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
ahirn@37877:    val f =
ahirn@37877:      Form'
ahirn@37877:        (PpcKF
ahirn@37877:           (0,EdUndef,0,Nundef,
ahirn@37877:            (Problem ["linear","univariate","equation"],
ahirn@37877:             {Find=[Correct "solutions L"],
ahirn@37877:              Given=[Correct "equality ((x + #1) * (x + #2) = x ^^^ #2 + #8)",
ahirn@37877:                     Correct "solveFor x"],Relate=[],
ahirn@37877:              Where=[False
ahirn@37877:                     "matches (?a + ?b * x = #0) ((x + #1) * (x + #2) = x ^^^ #2 + #8)"],
ahirn@37877:              With=[]}))) : mout 
neuper@37896: \end{verbatim}}
alexandra@37889: 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``].
ahirn@37877: {\footnotesize\begin{verbatim}
alexandra@37889: ????????????????????????????????????????????????????????????????????????????????????????????
ahirn@37877:    ML> val nxt = ("Refine_Problem",
ahirn@37877:                   Refine_Problem ["linear","univariate","equation
ahirn@37877:    ML> val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
ahirn@37877:    val f = Problems (RefinedKF [NoMatch #]) : mout
ahirn@37877:    ML>
ahirn@37877:    ML>  Compiler.Control.Print.printDepth:=9;f;Compiler.Control.Print.printDepth:=4;
ahirn@37877:    val f =
ahirn@37877:      Problems
ahirn@37877:        (RefinedKF
ahirn@37877:           [NoMatch
ahirn@37877:              (["linear","univariate","equation"],
ahirn@37877:               {Find=[Correct "solutions L"],
ahirn@37877:                Given=[Correct "equality ((x + #1) * (x + #2) = x ^^^ #2 + #8)",
ahirn@37877:                       Correct "solveFor x"],Relate=[],
ahirn@37877:                Where=[False
ahirn@37877:                      "matches (?a + ?b * x = #0) ((x + #1) * (x + #2) = x ^^^ #2 + #8)"],
ahirn@37877:                With=[]})]) : mout
ahirn@37877:    ML>
ahirn@37877:    ML> val nxt = ("Refine_Problem",Refine_Problem ["univariate","equation"]);
ahirn@37877:    ML> val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
ahirn@37877:    val f =
ahirn@37877:      Problems
ahirn@37877:        (RefinedKF [Matches #,NoMatch #,NoMatch #,NoMatch #,NoMatch #,Matches #])
ahirn@37877:      : mout
ahirn@37877:    ML>
ahirn@37877:    ML>
ahirn@37877:    ML>  Compiler.Control.Print.printDepth:=9;f;Compiler.Control.Print.printDepth:=4;
ahirn@37877:    val f =
ahirn@37877:      Problems
ahirn@37877:        (RefinedKF
ahirn@37877:           [Matches
ahirn@37877:              (["univariate","equation"],
ahirn@37877:               {Find=[Correct "solutions L"],
ahirn@37877:                Given=[Correct "equality ((x + #1) * (x + #2) = x ^^^ #2 + #8)",
ahirn@37877:                       Correct "solveFor x"],Relate=[],
ahirn@37877:                Where=[Correct
ahirn@37877:                With=[]}),
ahirn@37877:            NoMatch
ahirn@37877:              (["linear","univariate","equation"],
ahirn@37877:               {Find=[Correct "solutions L"],
ahirn@37877:                Given=[Correct "equality ((x + #1) * (x + #2) = x ^^^ #2 + #8)",
ahirn@37877:                       Correct "solveFor x"],Relate=[],
ahirn@37877:                Where=[False
ahirn@37877:                       "matches (?a + ?b * x = #0) ((x + #1) * (x + #2) = x ^^^ #2 + #8)"],
ahirn@37877:                   With=[]}),
ahirn@37877:            NoMatch
ahirn@37877:              ...
ahirn@37877:              ...   
ahirn@37877:            Matches
ahirn@37877:              (["normalize","univariate","equation"],
ahirn@37877:               {Find=[Correct "solutions L"],
ahirn@37877:                Given=[Correct "equality ((x + #1) * (x + #2) = x ^^^ #2 + #8)",
ahirn@37877:                       Correct "solveFor x"],Relate=[],Where=[],With=[]})]) : mout
neuper@37896: \end{verbatim}}
alexandra@37889: Die tactic {\tt Refine\_Problem} wandelt alle matches wieder in problem types um und sucht in der problem hierachy weiter.
ahirn@37877: 
alexandra@37889: 
alexandra@37889: \section{The phase of solving}
alexandra@37891: Diese phase beginnt mit dem Aufruf einer method, die eine normale form innerhalb einer tactic ausf\"uhrt: {\tt Rewrite rnorm\_equation\_add} und {\tt Rewrite\_Set SqRoot\_simplify}:
ahirn@37877: {\footnotesize\begin{verbatim} 
ahirn@37877:    ML> nxt;
ahirn@37877:    val it = ("Apply_Method",Apply_Method ("SqRoot.thy","norm_univar_equation"))
ahirn@37877:      : string * mstep
ahirn@37877:    ML>
ahirn@37877:    ML> val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
ahirn@37877:    val f =
ahirn@37877:      Form' (FormKF (~1,EdUndef,1,Nundef,"(x + #1) * (x + #2) = x ^^^ #2 + #8"))
ahirn@37877:    val nxt =
ahirn@37877:      ("Rewrite", Rewrite
ahirn@37877:         ("rnorm_equation_add","~ ?b =!= #0 ==> (?a = ?b) = (?a + #-1 * ?b = #0)"))
ahirn@37877:    ML>
ahirn@37877:    ML>  val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
ahirn@37877:    val f =
ahirn@37877:      Form' (FormKF (~1,EdUndef,1,Nundef,
ahirn@37877:            "(x + #1) * (x + #2) + #-1 * (x ^^^ #2 + #8) = #0")) : mout
ahirn@37877:    val nxt = ("Rewrite_Set",Rewrite_Set "SqRoot_simplify") : string * mstep
ahirn@37877:    ML>
ahirn@37877:    ML>  val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
ahirn@37877:    val f = Form' (FormKF (~1,EdUndef,1,Nundef,"#-6 + #3 * x = #0")) : mout
ahirn@37877:    val nxt = ("Subproblem",Subproblem ("SqRoot.thy",[#,#])) : string * mstep
neuper@37896: \end{verbatim}}
alexandra@37891: Die Formel $-6 + 3\cdot x = 0$ ist die Eingabe eine subproblems, das wiederum gebraucht wird, um die Gleichungsart zu erkennen und die entsprechende method auszuf\"uhren:
ahirn@37877: {\footnotesize\begin{verbatim}
ahirn@37877:    ML> nxt;
ahirn@37877:    val it = ("Subproblem",Subproblem ("SqRoot.thy",["univariate","equation"]))
ahirn@37877:    ML>   
ahirn@37877:    ML> val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
ahirn@37877:    val f =
ahirn@37877:      Form' (FormKF
ahirn@37877:           (~1,EdUndef,1,Nundef,"Subproblem (SqRoot.thy, [univariate, equation])"))
ahirn@37877:      : mout
ahirn@37877:    val nxt = ("Refine_Tacitly",Refine_Tacitly ["univariate","equation"])
ahirn@37877:    ML>
ahirn@37877:    ML> val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
ahirn@37877:    val nxt = ("Model_Problem",Model_Problem ["linear","univariate","equation"])
neuper@37896: \end{verbatim}}
alexandra@37889: {\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.
alexandra@37889: Nun folgt erneut die phase of modeling und die phase of specification.
ahirn@37877: 
alexandra@37889: \section{The final phase: \"Uberpr\"ufung der ''post-condition``}
alexandra@37891: 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 noch offene Fragen.
alexandra@37889: Dadurch wird die post-condition im folgenden Beispiel als problem und subproblem erw\"ahnt.
ahirn@37877: {\footnotesize\begin{verbatim}
ahirn@37877:    ML> nxt;
ahirn@37877:    val it = ("Check_Postcond",Check_Postcond ["linear","univariate","equation"])
ahirn@37877:    ML>
ahirn@37877:    ML>  val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
ahirn@37877:    val f = Form' (FormKF (~1,EdUndef,1,Nundef,"[x = #2]")) : mout
ahirn@37877:    val nxt =
ahirn@37877:      ("Check_Postcond",Check_Postcond ["normalize","univariate","equation"])
ahirn@37877:    ML>
ahirn@37877:    ML>  val (p,_,f,nxt,_,pt) = me nxt p [1] pt;
ahirn@37877:    val f = Form' (FormKF (~1,EdUndef,0,Nundef,"[x = #2]")) : mout
ahirn@37877:    val nxt = ("End_Proof'",End_Proof') : string * mstep
neuper@37896: \end{verbatim}}
alexandra@37889: Die tactic {\tt End\_Proof'} bedeutet, dass der proof erflogreich beendet wurde.\\
ahirn@37877: 
alexandra@37891: \paragraph{Versuchen Sie es!} 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.
ahirn@37877: 
ahirn@37877: 
alexandra@37891: \part{Handbuch f\"ur Autoren}
ahirn@37877: 
alexandra@37889: \chapter{Die Struktur des Grundlagenwissens}
ahirn@37877: 
alexandra@37891: \section{''tactics`` und Daten}
alexandra@37891: Zuerst betrachten wir die me von aussen. Wir sehen uns tactics 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.
alexandra@37889: Diese Teile sind in alphabetischer Anordnung in Tab.\ref{kb-items} auf Seite \pageref{kb-items} aufgelistet.
ahirn@37877: 
ahirn@37877: {\begin{table}[h]
alexandra@37889: \caption{Kleinste Teilchen des KB} \label{kb-items}
ahirn@37877: %\tabcolsep=0.3mm
ahirn@37877: \begin{center}
ahirn@37877: \def\arraystretch{1.0}
ahirn@37877: \begin{tabular}{lp{9.0cm}}
alexandra@37889: Abk\"urzung & Beschreibung \\
ahirn@37877: \hline
ahirn@37877: &\\
ahirn@37877: {\it calc\_list}
alexandra@37891: & gesammelte Liste von allen ausgewerteten Funktionen\\
ahirn@37877: {\it eval\_fn}
alexandra@37891: & ausgewertete Funktionen f\"ur Zahlen und f\"ur Eigenschaften, die in SML kodiert sind\\
alexandra@37889: {\it eval\_rls }
alexandra@37891: & rule set {\it rls} f\"ur einfache Ausdr\"ucke mit {\it eval\_fn}s\\
ahirn@37877: {\it fmz}
alexandra@37889: & Formalisierung, d.h. eine sehr geringe Darstellung von einem Beispiel \\
ahirn@37877: {\it met}
alexandra@37891: & eine method d.h. eine Datenstruktur, die alle Informationen zum L\"osen einer phase enth\"alt ({\it rew\_ord}, {\it scr}, etc.)\\
ahirn@37877: {\it metID}
alexandra@37889: & bezieht sich auf {\it met}\\
ahirn@37877: {\it op}
alexandra@37889: & ein Operator, der der Schl\"ussel zu {\it eval\_fn} in einer {\it calc\_list} ist \\
ahirn@37877: {\it pbl}
alexandra@37891: & Problem d.h. der Knotenpunkt in der problem hierachy\\
ahirn@37877: {\it pblID}
alexandra@37889: & bezieht sich auf {\it pbl}\\
ahirn@37877: {\it rew\_ord}
alexandra@37889: & Anordnung beim Rewriting\\
ahirn@37877: {\it rls}
alexandra@37891: & rule set, d.h. eine Datenstruktur, die theorems {\it thm} und Operatoren {\it op} zur Vereinfachung (mit {\it rew\_ord}) enth\"alt \\
ahirn@37877: {\it Rrls}
alexandra@37891: & rule set f\"ur das 'reverse rewriting' (eine \isac-Technik, die schrittweise Rewriting entwickelt, z.B. f\"ur die zur\"uckgenommenen Teile)\\
ahirn@37877: {\it scr}
alexandra@37891: & script, das die Algorithmen durch Anwenden von tactics beschreibt und ein Teil von {\it met} ist \\
ahirn@37877: {\it norm\_rls}
alexandra@37889: & spezielles Regelwerk zum Berechnen von Normalformen, im Zusammenhang mit {\it thy}\\
ahirn@37877: {\it spec}
alexandra@37889: & Spezifikation, z.B, ein Tripel ({\it thyID, pblID, metID})\\
ahirn@37877: {\it subs}
alexandra@37889: & Ersatz, z.B. eine Liste von Variablen und ihren jeweiligen Werten\\
alexandra@37892: {\it Term}
alexandra@37889: & Term von Isabelle, z.B. eine Formel\\
ahirn@37877: {\it thm}
alexandra@37889: & theorem\\
ahirn@37877: {\it thy}
alexandra@37891: & theory\\
ahirn@37877: {\it thyID}
alexandra@37889: & im Bezug auf {\it thy} \\
alexandra@37889: \end{tabular}\end{center}\end{table}}
alexandra@37889: 
alexandra@37891: Die Verbindung zwischen tactics und Daten werden in Tab.\ref{tac-kb} auf Seite \pageref{tac-kb} dargestellt.
alexandra@37889: 
alexandra@37889: 
ahirn@37877: \begin{table}[h]
alexandra@37891: \caption{Welche tactics verwenden die Teile des KB~?} \label{tac-kb}
ahirn@37877: \tabcolsep=0.3mm
ahirn@37877: \begin{center}
ahirn@37877: \begin{tabular}{|ll||cccc|ccc|cccc|} \hline
alexandra@37891: tactic &Eingabe & & & &norm\_& &rew\_&rls &eval\_&eval\_&calc\_& \\
alexandra@37889: & &thy &scr &Rrls&rls &thm &ord &Rrls&fn &rls &list &dsc\\
ahirn@37877: \hline\hline
ahirn@37877: Init\_Proof
alexandra@37889: &fmz & x & & & x & & & & & & & x \\
alexandra@37889: &spec & & & & & & & & & & & \\
ahirn@37877: \hline
ahirn@37877: \multicolumn{13}{|l|}{model phase}\\
ahirn@37877: \hline
alexandra@37889: Add\_*
alexandra@37892: &Term & x & & & x & & & & & & & x \\
alexandra@37889: FormFK &model & x & & & x & & & & & & & x \\
ahirn@37877: \hline
ahirn@37877: \multicolumn{13}{|l|}{specify phase}\\
ahirn@37877: \hline
alexandra@37889: Specify\_Theory
alexandra@37889: &thyID & x & & & x & & & & x & x & & x \\
alexandra@37889: Specify\_Problem
alexandra@37889: &pblID & x & & & x & & & & x & x & & x \\
alexandra@37889: Refine\_Problem
alexandra@37889: &pblID & x & & & x & & & & x & x & & x \\
alexandra@37889: Specify\_Method
alexandra@37889: &metID & x & & & x & & & & x & x & & x \\
alexandra@37889: Apply\_Method
alexandra@37889: &metID & x & x & & x & & & & x & x & & x \\
ahirn@37877: \hline
ahirn@37877: \multicolumn{13}{|l|}{solve phase}\\
ahirn@37877: \hline
alexandra@37889: Rewrite,\_Inst
alexandra@37889: &thm & x & x & & & x &met & & x &met & & \\
ahirn@37877: Rewrite, Detail
alexandra@37889: &thm & x & x & & & x &rls & & x &rls & & \\
ahirn@37877: Rewrite, Detail
alexandra@37889: &thm & x & x & & & x &Rrls & & x &Rrls & & \\
ahirn@37877: Rewrite\_Set,\_Inst
alexandra@37889: &rls & x & x & & & & & x & x & x & & \\
alexandra@37889: Calculate
alexandra@37889: &op & x & x & & & & & & & & x & \\
alexandra@37889: Substitute
alexandra@37889: &subs & x & & & x & & & & & & & \\
alexandra@37889: & & & & & & & & & & & & \\
alexandra@37889: SubProblem
alexandra@37889: &spec & x & x & & x & & & & x & x & & x \\
alexandra@37889: &fmz & & & & & & & & & & & \\
ahirn@37877: \hline
neuper@37896: \end{tabular}\end{center}\end{table}
ahirn@37877: 
ahirn@37877: 
alexandra@37889: \section{Die theories von \isac{}}
alexandra@37891: 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} gekennzeichnet sind; normalerweise werden diese theories zusammen mit SML verwendet. Dann haben sie den selben Dateinamen, aber die Endung {\tt *.ML}.
alexandra@37891: Die theories von \isac{} representieren den Teil vom Basiswissen von \isac{}, die hierachy von den zwei theories ist nach diesen strukturiert. Die {\tt *.ML} Dateien beinhalten {\em alle} Daten von den anderen zwei Hauptlinien des Basiswissens, die problems und methods (ohne ihre jeweilige Struktur, die von den problem Browsern und den method Browsern gemacht wird, zu pr\"asentieren.
alexandra@37891: Die Tab.\ref{theories} auf Seite \pageref{theories} listet die base 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.
alexandra@37891: Die ersten drei theories auf der Liste geh\"oren {\em nicht} zum Grundwissen von \isac{}; sie besch\"aftigen sich mit der Skriptsprache f\"ur methods und ist hier nur zur Vollst\"andigkeit angef\"uhrt.
ahirn@37877: 
ahirn@37877: {\begin{table}[h]
alexandra@37891: \caption{theory von der ersten Version von \isac} \label{theories}
ahirn@37877: %\tabcolsep=0.3mm
ahirn@37877: \begin{center}
ahirn@37877: \def\arraystretch{1.0}
ahirn@37877: \begin{tabular}{lp{9.0cm}}
alexandra@37891: theory & Beschreibung \\
ahirn@37877: \hline
ahirn@37877: &\\
ahirn@37877: ListI.thy
alexandra@37891: & ordnet die Bezeichnungen den Funktionen, die in {\tt Isabelle2002/src/HOL/List.thy} sind, zu und (intermediatly~?) definiert einige weitere Listen von Funktionen\\
ahirn@37877: ListI.ML
alexandra@37889: & {\tt eval\_fn} f\"ur die zus\"atzliche Listen von Funktionen\\
ahirn@37877: Tools.thy
alexandra@37889: & Funktion, die f\"ur die Auswertung von Skripten ben\"otigt wird\\
ahirn@37877: Tools.ML
alexandra@37889: & bezieht sich auf {\tt eval\_fn}s\\
ahirn@37877: Script.thy
alexandra@37891: & Vorraussetzung f\"ur script: types, tactics, tacticals\\
ahirn@37877: Script.ML
alexandra@37891: & eine Reihe von tactics und Funktionen f\"ur den internen Gebrauch\\
ahirn@37877: & \\
ahirn@37877: \hline
ahirn@37877: & \\
ahirn@37877: Typefix.thy
alexandra@37889: & fortgeschrittener Austritt, um den type Fehlern zu entkommen\\
ahirn@37877: Descript.thy
alexandra@37889: & {\it Beschreibungen} f\"ur die Formeln von {\it Modellen} und {\it Problemen}\\
ahirn@37877: Atools
alexandra@37891: & Neudefinierung von Operatoren; allgemeine Eigenschaften und Funktionen f\"ur Vorraussetzungen; theorems f\"ur {\tt eval\_rls}\\
ahirn@37877: Float
alexandra@37889: & Gleitkommerzahlendarstellung\\
ahirn@37877: Equation
alexandra@37889: & grunds\"atzliche Vorstellung f\"ur  Gleichungen und Gleichungssysteme\\
ahirn@37877: Poly
alexandra@37889: & Polynome\\
ahirn@37877: PolyEq
alexandra@37889: & polynomiale Gleichungen und Gleichungssysteme \\
ahirn@37877: Rational.thy
alexandra@37891: & zus\"atzliche theorems f\"ur Rationale Zahlen\\
ahirn@37877: Rational.ML
alexandra@37889: & abbrechen, hinzuf\"ugen und vereinfachen von Rationalen Zahlen durch Verwenden von (einer allgemeineren Form von) Euclids Algorithmus; die entsprechenden umgekehrten Regels\"atze\\
ahirn@37877: RatEq
alexandra@37889: & Gleichung mit rationalen Zahlen\\
ahirn@37877: Root
alexandra@37889: & Radikanten; berechnen der Normalform; das betreffende umgekehrte Regelwerk\\
ahirn@37877: RootEq
alexandra@37889: & Gleichungen mit Wurzeln\\
ahirn@37877: RatRootEq
alexandra@37889: & Gleichungen mit rationalen Zahlen und Wurzeln (z.B. mit Termen, die beide Vorg\"ange enthalten)\\
ahirn@37877: Vect
alexandra@37889: & Vektoren Analysis\\
ahirn@37877: Trig
alexandra@37889: & Trigonometrie\\
ahirn@37877: LogExp
alexandra@37889: & Logarithmus und Exponentialfunktionen\\
ahirn@37877: Calculus
alexandra@37889: & nicht der Norm entsprechende Analysis\\
ahirn@37877: Diff
alexandra@37889: & Differenzierung\\
ahirn@37877: DiffApp
alexandra@37889: & Anwendungen beim Differenzieren (Maximum-Minimum-Probleme)\\
ahirn@37877: Test
alexandra@37889: & (alte) Daten f\"ur Testfolgen\\
ahirn@37877: Isac
alexandra@37889: & enth\"alt alle Theorien von\isac{}\\
alexandra@37889: \end{tabular}\end{center}\end{table}}
ahirn@37877: 
ahirn@37877: 
alexandra@37889: \section{Daten in {\tt *.thy} und {\tt *.ML}}
alexandra@37891: Wie schon zuvor angesprochen, haben die Arbeiten die theories von *.thy und *.ML zusammen und haben deswegen den selben Dateiname. Wie diese Daten zwischen den zwei Dateien verteilt werden wird in der
alexandra@37891: Tab.\ref{thy-ML} auf Seite \pageref{thy-ML} gezeigt. Die Ordnung von den Datenteilchen in den theories sollte an der Ordnung von der Liste festhalten.
alexandra@37889: 
ahirn@37877: {\begin{table}[h]
alexandra@37889: \caption{Daten in {\tt *.thy}- und {\tt *.ML}-files} \label{thy-ML}
ahirn@37877: \tabcolsep=2.0mm
ahirn@37877: \begin{center}
ahirn@37877: \def\arraystretch{1.0}
ahirn@37877: \begin{tabular}{llp{7.7cm}}
alexandra@37889: Datei & Daten & Beschreibung \\
ahirn@37877: \hline
ahirn@37877: & &\\
ahirn@37877: {\tt *.thy}
alexandra@37889: & consts
alexandra@37889: & Operatoren, Eigenschaften, Funktionen und Skriptnamen ('{\tt Skript} Name \dots{\tt Argumente}')
ahirn@37877: \\
alexandra@37889: & rules
alexandra@37891: & theorems: \isac{} verwendet theorems von Isabelle, wenn m\"oglich; zus\"atzliche theorems, die jenen von Isabelle entsprechen, bekommen ein {\it I} angeh\"angt
ahirn@37877: \\& &\\
ahirn@37877: {\tt *.ML}
alexandra@37889: & {\tt theory' :=}
alexandra@37891: & Die theory, die 
alexandra@37889: abgegrenzt ist von der {\tt *.thy}-Datei, wird durch \isac{} zug\"anglich gemacht
ahirn@37877: \\
ahirn@37877: & {\tt eval\_fn}
alexandra@37891: & 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
alexandra@37891: \\
alexandra@37889: & {\tt *\_simplify}
alexandra@37889: & 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}
ahirn@37877: \\
ahirn@37877: & {\tt norm\_rls :=}
alexandra@37891: & der automatisierte Vereinfacher {\tt *\_simplify} wird so aufgehoben, dass er \"uber \isac{}  zug\"anglich ist
ahirn@37877: \\
ahirn@37877: & {\tt rew\_ord' :=}
alexandra@37889: & das Gleiche f\"ur die Anordnung des Rewriting, wenn es ausserhalb eines speziellen Regelwerks gebraucht wird
ahirn@37877: \\
ahirn@37877: & {\tt ruleset' :=}
alexandra@37889: & dasselbe wie f\"ur Regels\"atze (gew\"ohnliche Regels\"atze, umgekehrte Regels\"atze, und {\tt eval\_rls})
ahirn@37877: \\
ahirn@37877: & {\tt calc\_list :=}
alexandra@37891: & 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 tactic {\tt Calculate} in einem Skript)
ahirn@37877: \\
ahirn@37877: & {\tt store\_pbl}
alexandra@37891: & Problems, die in {\tt *.ML}-Dateien definiert sind, werden zug\"anglich f\"ur \isac{}
ahirn@37877: \\
ahirn@37877: & {\tt methods :=}
alexandra@37891: & methods, die in {\tt *.ML}-Dateien definiert sind werden zug\"anglich f\"ur \isac{}
ahirn@37877: \\
alexandra@37889: \end{tabular}\end{center}\end{table}}
ahirn@37877: 
alexandra@37889: \section{Formale Beschreibung der Hierarchie von Problemen}
ahirn@37877: 
alexandra@37889: \section{Skripttaktiken}
alexandra@37891: Tats\"achlich sind es die tactics, die die Berechnungen vorantreiben: im Hintergrund bauen sie den proof tree 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 tactics; die Semantik ist beschrieben etwas weiter unten im Kontext mit tactics, die die Benutzer/Innen dieses Programmes verwenden: Es gibt einen Schriftverkehr zwischen den user-tactics und den script tactics.
ahirn@37877: 
ahirn@37877: 
ahirn@37877: 
ahirn@37877: \part{Authoring on the knowledge}
ahirn@37877: 
ahirn@37877: 
ahirn@37877: \section{Add a theorem}
ahirn@37877: \section{Define and add a problem}
ahirn@37877: \section{Define and add a predicate}
ahirn@37877: \section{Define and add a method}
ahirn@37877: \section{}
ahirn@37877: \section{}
ahirn@37877: \section{}
ahirn@37877: \section{}
ahirn@37877: 
ahirn@37877: 
ahirn@37877: 
ahirn@37877: \newpage
ahirn@37877: \bibliography{bib/isac,bib/from-theses}
ahirn@37877: 
ahirn@37877: \end{document}




