(* Title:  Build_Inverse_Z_Transform

   Author: Jan Rocnik

   (c) copyright due to license terms.

*)

theory Build_Inverse_Z_Transform imports Isac.Inverse_Z_Transform

begin

text\<open>We stepwise build \ttfamily Inverse\_Z\_Transform.thy \normalfont as an 

  exercise. Because Subsection~\ref{sec:stepcheck} requires 

  \ttfamily Inverse\_Z\_Transform.thy \normalfont as a subtheory of \ttfamily 

  Isac.thy\normalfont, the setup has been changed from \ttfamily theory 

  Inverse\_Z\_Transform imports Isac \normalfont to the above one.

  \par \noindent

  \begin{center} 

  \textbf{Attention with the names of identifiers when going into internals!}

  \end{center}

  Here in this theory there are the internal names twice, for instance we have

  \ttfamily (Thm.derivation\_name @{thm rule1} = 

  "Build\_Inverse\_Z\_Transform.rule1") = true; \normalfont

  but actually in us will be \ttfamily Inverse\_Z\_Transform.rule1 \normalfont

\<close>

section \<open>Trials towards the Z-Transform\label{sec:trials}\<close>

ML \<open>val thy = @{theory};\<close>

subsection \<open>Notations and Terms\<close>

text\<open>\noindent Try which notations we are able to use.\<close>

ML \<open>

  @{term "1 < || z ||"};

  @{term "z / (z - 1)"};

  @{term "-u -n - 1"};

  @{term "-u [-n - 1]"}; (*[ ] denotes lists !!!*)

  @{term "z /(z - 1) = -u [-n - 1]"};

  @{term "1 < || z || ==> z / (z - 1) = -u [-n - 1]"};

  UnparseC.term @{term "1 < || z || ==> z / (z - 1) = -u [-n - 1]"};

\<close>

text\<open>\noindent Try which symbols we are able to use and how we generate them.\<close>

ML \<open>

  (*alpha -->  "</alpha>" *)

  @{term "\<alpha> "};

  @{term "\<delta> "};

  @{term "\<phi> "};

  @{term "\<rho> "};

  UnparseC.term @{term "\<rho> "};

\<close>

subsection \<open>Rules\<close>

(*axiomatization "z / (z - 1) = -u [-n - 1]"

  Illegal variable name: "z / (z - 1) = -u [-n - 1]" *)

(*definition     "z / (z - 1) = -u [-n - 1]"

  Bad head of lhs: existing constant "op /"*)

axiomatization where 

  rule1: "1 = \<delta>[n]" and

  rule2: "|| z || > 1 ==> z / (z - 1) = u [n]" and

  rule3: "|| z || < 1 ==> z / (z - 1) = -u [-n - 1]" and 

  rule4: "|| z || > || \<alpha> || ==> z / (z - \<alpha>) = \<alpha> \<up> n * u [n]" and

  rule5: "|| z || < || \<alpha> || ==> z / (z - \<alpha>) = -(\<alpha> \<up> n) * u [-n - 1]" and

  rule6: "|| z || > 1 ==> z/(z - 1) \<up> 2 = n * u [n]"

text\<open>\noindent Check the rules for their correct notation. 

      (See the machine output.)\<close>

ML \<open>

  @{thm rule1};

  @{thm rule2};

  @{thm rule3};

  @{thm rule4};

\<close>

subsection \<open>Apply Rules\<close>

text\<open>\noindent We try to apply the rules to a given expression.\<close>

ML \<open>

  val inverse_Z = Rule_Set.append_rules "inverse_Z" Atools_erls

    [ \<^rule_thm>\<open>rule3\<close>,

      \<^rule_thm>\<open>rule4\<close>,

      \<^rule_thm>\<open>rule1\<close>   

    ];

\<close> ML \<open>

  val t = TermC.parse_test @{context} "z / (z - 1) + z / (z - \<alpha>) + 1::real";

\<close> ML \<open>

  val SOME (t', asm) = Rewrite.rewrite_set_ thy true inverse_Z t;

(*rewrite__set_ called with 'Erls' for '|| z || < 1'*)

\<close> ML \<open>

  UnparseC.term t' = "z / (z - ?\<delta> [?n]) + z / (z - \<alpha>) + ?\<delta> [?n]";

  (*

   * Attention rule1 is applied before the expression is 

   * checked for rule4 which would be correct!!!

   *)

\<close> ML \<open>

\<close>

ML \<open>val (thy, ro, er) = (@{theory}, tless_true, eval_rls);\<close>

ML \<open>

  val SOME (t, asm1) = 

    Rewrite.rewrite_ thy ro er true (ThmC.numerals_to_Free @{thm rule3}) t;

  UnparseC.term t = "- ?u [- ?n - 1] + z / (z - \<alpha>) + 1";

  (*- real *)

  UnparseC.term t;

  val SOME (t, asm2) = 

    Rewrite.rewrite_ thy ro er true (ThmC.numerals_to_Free @{thm rule4}) t;

  UnparseC.term t = "- ?u [- ?n - 1] + \<alpha> \<up> ?n * ?u [?n] + 1";

  (*- real *)

  UnparseC.term t;

  val SOME (t, asm3) = 

    Rewrite.rewrite_ thy ro er true (ThmC.numerals_to_Free @{thm rule1}) t;

  UnparseC.term t = "- ?u [- ?n - 1] + \<alpha> \<up> ?n * ?u [?n] + ?\<delta> [?n]";

  (*- real *)

  UnparseC.term t;

\<close>

ML \<open>UnparseC.terms (asm1 @ asm2 @ asm3);\<close>

section\<open>Prepare Steps for TP-based programming Language\label{sec:prepstep}\<close>

text\<open>

      \par \noindent The following sections are challenging with the CTP-based 

      possibilities of building the program. The goal is realized in 

      Section~\ref{spec-meth} and Section~\ref{prog-steps}.

      \par The reader is advised to jump between the subsequent subsections and 

      the respective steps in Section~\ref{prog-steps}. By comparing 

      Section~\ref{sec:calc:ztrans} the calculation can be comprehended step 

      by step.

\<close>

subsection \<open>Prepare Expression\label{prep-expr}\<close>

text\<open>\noindent We try two different notations and check which of them 

       Isabelle can handle best.\<close>

ML \<open>

  val ctxt = Proof_Context.init_global @{theory};

(*val ctxt = ContextC.declare_constraints' [@{term "z::real"}] ctxt;*)

  val SOME fun1 = 

    TermC.parseNEW ctxt "X z = 3 / (z - 1/4 + -1/8 * z \<up> -1)"; UnparseC.term fun1;

  val SOME fun1' = 

    TermC.parseNEW ctxt "X z = 3 / (z - 1/4 + -1/8 * (1/z))"; UnparseC.term fun1';

\<close>

subsubsection \<open>Prepare Numerator and Denominator\<close>

text\<open>\noindent The partial fraction decomposition is only possible if we

       get the bound variable out of the numerator. Therefor we divide

       the expression by $z$. Follow up the Calculation at 

       Section~\ref{sec:calc:ztrans} line number 02.\<close>

axiomatization where

  ruleZY: "(X z = a / b) = (X' z = a / (z * b))"

ML \<open>

  val (thy, ro, er) = (@{theory}, tless_true, eval_rls);

  val SOME (fun2, asm1) = 

    Rewrite.rewrite_ thy ro er true  @{thm ruleZY} fun1; UnparseC.term fun2;

  val SOME (fun2', asm1) = 

    Rewrite.rewrite_ thy ro er true  @{thm ruleZY} fun1'; UnparseC.term fun2';

  val SOME (fun3,_) = 

    Rewrite.rewrite_set_ @{theory} false norm_Rational fun2;

  UnparseC.term fun3;

  (*

   * Fails on x \<up> (-1)

   * We solve this problem by using 1/x as a workaround.

   *)

  val SOME (fun3',_) = 

    Rewrite.rewrite_set_ @{theory} false norm_Rational fun2';

  UnparseC.term fun3';

  (*

   * OK - workaround!

   *)

\<close>

subsubsection \<open>Get the Argument of the Expression X'\<close>

text\<open>\noindent We use \texttt{grep} for finding possibilities how we can

       extract the bound variable in the expression. \ttfamily Prog_Expr.thy, 

       Tools.thy \normalfont contain general utilities: \ttfamily 

       eval\_argument\_in, eval\_rhs, eval\_lhs,\ldots \normalfont

       \ttfamily grep -r "fun eva\_" * \normalfont shows all functions 

       witch can be used in a script. Lookup this files how to build 

       and handle such functions.

       \par The next section shows how to introduce such a function.

\<close>

subsubsection\<open>Decompose the Given Term Into lhs and rhs\<close>

ML \<open>

  val (_, expr) = HOLogic.dest_eq fun3'; UnparseC.term expr;

  val (_, denom) = 

    HOLogic.dest_bin \<^const_name>\<open>divide\<close> (type_of expr) expr;

  UnparseC.term denom = "-1 + -2 * z + 8 * z \<up> 2";

\<close>

text\<open>\noindent We have rhs\footnote{Note: lhs means \em Left Hand Side

      \normalfont and rhs means \em Right Hand Side \normalfont and indicates

      the left or the right part of an equation.} in the Program language, but

      we need a function which gets the denominator of a fraction.\<close>

subsubsection\<open>Get the Denominator and Numerator out of a Fraction\<close>

text\<open>\noindent The self written functions in e.g. \texttt{get\_denominator}

       should become a constant for the Isabelle parser:\<close>

consts

  get_denominator :: "real => real"

  get_numerator :: "real => real"

text \<open>\noindent With the above definition we run into problems when we parse

        the Program \texttt{InverseZTransform}. This leads to \em ambiguous

        parse trees. \normalfont We avoid this by moving the definition

        to \ttfamily Rational.thy \normalfont and re-building {\sisac}.

        \par \noindent ATTENTION: From now on \ttfamily 

        Build\_Inverse\_Z\_Transform \normalfont mimics a build from scratch;

        it only works due to re-building {\sisac} several times (indicated 

        explicitly).

\<close>

ML \<open>

(*

 *("get_denominator",

 *  ("Rational.get_denominator", eval_get_denominator ""))

 *)

fun eval_get_denominator (thmid:string) _ 

		      (t as Const (\<^const_name>\<open>get_denominator\<close>, _) $

              (Const (\<^const_name>\<open>divide\<close>, _) $num 

                $denom)) thy = 

        SOME (TermC.mk_thmid thmid (UnparseC.term_in_thy thy denom) "", 

	        HOLogic.Trueprop $ (TermC.mk_equality (t, denom)))

  | eval_get_denominator _ _ _ _ = NONE; 

\<close>

text \<open>\noindent For the tests of \ttfamily eval\_get\_denominator \normalfont

        see \ttfamily test/Knowledge/rational.sml\normalfont\<close>

text \<open>\noindent \ttfamily get\_numerator \normalfont should also become a

        constant for the Isabelle parser, follow up the \texttt{const}

        declaration above.\<close>

ML \<open>

(*

 *("get_numerator",

 *  ("Rational.get_numerator", eval_get_numerator ""))

 *)

fun eval_get_numerator (thmid:string) _ 

		      (t as Const (\<^const_name>\<open>Rational.get_numerator\<close>, _) $

              (Const (\<^const_name>\<open>divide\<close>, _) $num

                $denom )) thy = 

        SOME (TermC.mk_thmid thmid (UnparseC.term_in_thy thy num) "", 

	        HOLogic.Trueprop $ (TermC.mk_equality (t, num)))

  | eval_get_numerator _ _ _ _ = NONE; 

\<close>

text \<open>\noindent We discovered several problems by implementing the 

       \ttfamily get\_numerator \normalfont function. Remember when 

       putting new functions to {\sisac}, put them in a thy file and rebuild 

       {\sisac}, also put them in the ruleset for the script!\<close>

subsection \<open>Solve Equation\label{sec:solveq}\<close>

text \<open>\noindent We have to find the zeros of the term, therefor we use our

       \ttfamily get\_denominator \normalfont function from the step before

       and try to solve the second order equation. (Follow up the Calculation

       in Section~\ref{sec:calc:ztrans} Subproblem 2) Note: This type of

       equation is too general for the present program.

       \par We know that this equation can be categorized as \em univariate

       equation \normalfont and solved with the functions {\sisac} provides

       for this equation type. Later on {\sisac} should determine the type

       of the given equation self.\<close>

ML \<open>

  val denominator = TermC.parseNEW ctxt "z \<up> 2 - 1/4*z - 1/8 = 0";

  val fmz = ["equality (z \<up> 2 - 1/4*z - 1/8 = (0::real))",

             "solveFor z",

             "solutions L"];

  val (dI',pI',mI') =("Isac_Knowledge", ["univariate", "equation"], ["no_met"]);

\<close>

text \<open>\noindent Check if the given equation matches the specification of this

        equation type.\<close>

ML \<open>

  M_Match.match_pbl fmz (Problem.from_store ["univariate", "equation"]);

\<close>

text\<open>\noindent We switch up to the {\sisac} Context and try to solve the 

       equation with a more specific type definition.\<close>

ML \<open>

  Context.theory_name thy = "Isac_Knowledge";

  val denominator = TermC.parseNEW ctxt "-1 + -2 * z + 8 * z \<up> 2 = 0";

  val fmz =                                             (*specification*)

    ["equality (-1 + -2 * z + 8 * z \<up> 2 = (0::real))",(*equality*)

     "solveFor z",                                      (*bound variable*)

     "solutions L"];                                    (*identifier for

                                                          solution*)

  val (dI',pI',mI') =

    ("Isac_Knowledge", 

      ["abcFormula", "degree_2", "polynomial", "univariate", "equation"],

      ["no_met"]);

\<close>

text \<open>\noindent Check if the (other) given equation matches the 

        specification of this equation type.\<close>

ML \<open>

  M_Match.match_pbl fmz (Problem.from_store

    ["abcFormula", "degree_2", "polynomial", "univariate", "equation"]);

\<close>

text \<open>\noindent We stepwise solve the equation. This is done by the

        use of a so called calc tree seen downwards.\<close>

ML \<open>

  val (p,_,f,nxt,_,pt) = Test_Code.init_calc @{context} [(fmz, (dI',pI',mI'))];

  val (p,_,f,nxt,_,pt) = me nxt p [] pt;

  val (p,_,f,nxt,_,pt) = me nxt p [] pt;

  val (p,_,f,nxt,_,pt) = me nxt p [] pt;

  val (p,_,f,nxt,_,pt) = me nxt p [] pt;

  val (p,_,f,nxt,_,pt) = me nxt p [] pt;

  val (p,_,f,nxt,_,pt) = me nxt p [] pt;

  val (p,_,f,nxt,_,pt) = me nxt p [] pt;

  val (p,_,f,nxt,_,pt) = me nxt p [] pt;

  val (p,_,f,nxt,_,pt) = me nxt p [] pt;

  val (p,_,f,nxt,_,pt) = me nxt p [] pt;

  val (p,_,f,nxt,_,pt) = me nxt p [] pt;         

  val (p,_,f,nxt,_,pt) = me nxt p [] pt;

  (*

   * nxt =..,Check_elementwise "Assumptions") 

   *)

  val (p,_,f,nxt,_,pt) = me nxt p [] pt;         

  val (p,_,f,nxt,_,pt) = me nxt p [] pt; f2str f;

  (*

   * [z = 1 / 2, z = -1 / 4]

   *)

  Test_Tool.show_pt pt; 

  val SOME f = parseNEW ctxt "[z=1/2, z=-1/4]";

\<close>

subsection \<open>Partial Fraction Decomposition\label{sec:pbz}\<close>

text\<open>\noindent We go on with the decomposition of our expression. Follow up the

       Calculation in Section~\ref{sec:calc:ztrans} Step~3 and later on

       Subproblem~1.\<close>

subsubsection \<open>Solutions of the Equation\<close>

text\<open>\noindent We get the solutions of the before solved equation in a list.\<close>

ML \<open>

  val SOME solutions = parseNEW ctxt "[z=1/2, z=-1/4]";

  UnparseC.term solutions;

  TermC.atom_trace_detail @{context} solutions;

\<close>

subsubsection \<open>Get Solutions out of a List\<close>

text \<open>\noindent In {\sisac}'s TP-based programming language: 

\begin{verbatim}

  let $ $ s_1 = NTH 1 $ solutions; $ s_2 = NTH 2... $

\end{verbatim}

       can be useful.

\<close>

ML \<open>

  val Const (\<^const_name>\<open>Cons\<close>, _) $ s_1 $ (Const (\<^const_name>\<open>Cons\<close>, _)

        $ s_2 $ Const (\<^const_name>\<open>Nil\<close>, _)) = solutions;

  UnparseC.term s_1;

  UnparseC.term s_2;

\<close>

text\<open>\noindent The ansatz for the \em Partial Fraction Decomposition \normalfont

      requires to get the denominators of the partial fractions out of the 

      Solutions as:

      \begin{itemize}

        \item $Denominator_{1}=z-Zeropoint_{1}$

        \item $Denominator_{2}=z-Zeropoint_{2}$

        \item \ldots

      \end{itemize}

\<close>

ML \<open>

  val xx = HOLogic.dest_eq s_1;

  val s_1' = HOLogic.mk_binop \<^const_name>\<open>minus\<close> xx;

  val xx = HOLogic.dest_eq s_2;

  val s_2' = HOLogic.mk_binop \<^const_name>\<open>minus\<close> xx;

  UnparseC.term s_1';

  UnparseC.term s_2';

\<close>

text \<open>\noindent For the programming language a function collecting all the 

        above manipulations is helpful.\<close>

ML \<open>

  fun fac_from_sol s =

    let val (lhs, rhs) = HOLogic.dest_eq s

    in HOLogic.mk_binop \<^const_name>\<open>minus\<close> (lhs, rhs) end;

\<close>

ML \<open>

  fun mk_prod prod [] =

        if prod = TermC.empty

        then error "mk_prod called with []" 

        else prod

    | mk_prod prod (t :: []) =

        if prod = TermC.empty

        then t

        else HOLogic.mk_binop \<^const_name>\<open>times\<close> (prod, t)

    | mk_prod prod (t1 :: t2 :: ts) =

          if prod = TermC.empty 

          then 

             let val p = 

               HOLogic.mk_binop \<^const_name>\<open>times\<close> (t1, t2)

             in mk_prod p ts end 

          else 

             let val p =

               HOLogic.mk_binop \<^const_name>\<open>times\<close> (prod, t1)

             in mk_prod p (t2 :: ts) end 

\<close>

(* ML {* 

probably keep these test in test/Tools/isac/...

(*mk_prod TermC.empty [];*)

val prod = mk_prod TermC.empty [parse_test @{context} "x + 123"]; 

UnparseC.term prod = "x + 123";

val sol = parse_test @{context} "[z = 1 / 2, z = -1 / 4]";

val sols = HOLogic.dest_list sol;

val facs = map fac_from_sol sols;

val prod = mk_prod TermC.empty facs; 

UnparseC.term prod = "(z + -1 * (1 / 2)) * (z + -1 * (-1 / 4))";

val prod = 

  mk_prod TermC.empty [parse_test @{context} "x + 1", parse_test @{context} "x + 2", parse_test @{context} "x + 3"]; 

UnparseC.term prod = "(x + 1) * (x + 2) * (x + 3)";

*} *)

ML \<open>

  fun factors_from_solution sol = 

    let val ts = HOLogic.dest_list sol

    in mk_prod TermC.empty (map fac_from_sol ts) end;

\<close>

(* ML {*

val sol = parse_test @{context} "[z = 1 / 2, z = -1 / 4]";

val fs = factors_from_solution sol;

UnparseC.term fs = "(z + -1 * (1 / 2)) * (z + -1 * (-1 / 4))"

*} *)

text \<open>\noindent This function needs to be packed such that it can be evaluated

        by the Lucas-Interpreter. Therefor we moved the function to the

        corresponding \ttfamily Equation.thy \normalfont in our case

        \ttfamily PartialFractions.thy \normalfont. The necessary steps

        are quit the same as we have done with \ttfamily get\_denominator 

        \normalfont before.\<close>

ML \<open>

  (*("factors_from_solution",

    ("Partial_Fractions.factors_from_solution",

      eval_factors_from_solution ""))*)

  fun eval_factors_from_solution (thmid:string) _

      (t as Const ("Partial_Fractions.factors_from_solution", _) $ sol) thy =

        let val prod = factors_from_solution sol

        in SOME (TermC.mk_thmid thmid (UnparseC.term_in_thy thy prod) "",

             HOLogic.Trueprop $ (TermC.mk_equality (t, prod)))

        end

    | eval_factors_from_solution _ _ _ _ = NONE;

\<close>

text \<open>\noindent The tracing output of the calc tree after applying this

       function was:

\begin{verbatim}

  24 / factors_from_solution [z = 1/ 2, z = -1 / 4])]

\end{verbatim}

       and the next step:

\begin{verbatim}

  val nxt = ("Empty_Tac", ...): tac'_)

\end{verbatim}

       These observations indicate, that the Lucas-Interpreter (LIP) 

       does not know how to evaluate \ttfamily factors\_from\_solution

       \normalfont, so we knew that there is something wrong or missing.

\<close>

text\<open>\noindent First we isolate the difficulty in the program as follows:

\begin{verbatim}      

  " (L_L::bool list) = (SubProblem (PolyEqX,      " ^

  "   [abcFormula, degree_2, polynomial,          " ^

  "    univariate,equation],                      " ^

  "   [no_met])                                   " ^

  "   [BOOL equ, REAL zzz]);                      " ^

  " (facs::real) = factors_from_solution L_L;     " ^

  " (foo::real) = Take facs                       " ^

\end{verbatim}

      \par \noindent And see the tracing output:

\begin{verbatim}

  [(([], Frm), Problem (Isac, [inverse, 

                               Z_Transform,

                                SignalProcessing])),

   (([1], Frm), X z = 3 / (z - 1 / 4 + -1 / 8 * (1 / z))),

   (([1], Res), ?X' z = 3 / (z * (z - 1 / 4 + -1 / 8 * (1 / z)))),

   (([2], Res), ?X' z = 24 / (-1 + -2 * z + 8 * z \<up> 2)),

   (([3], Pbl), solve (-1 + -2 * z + 8 * z \<up> 2 = 0, z)),

   (([3,1], Frm), -1 + -2 * z + 8 * z \<up> 2 = 0),

   (([3,1], Res), z = (- -2 + sqrt (-2 \<up> 2 - 4 * 8 * -1)) / (2 * 8)|

                  z = (- -2 - sqrt (-2 \<up> 2 - 4 * 8 * -1)) / (2 * 8)),

   (([3,2], Res), z = 1 / 2 | z = -1 / 4),

   (([3,3], Res), [ z = 1 / 2, z = -1 / 4]),

   (([3,4], Res), [ z = 1 / 2, z = -1 / 4]),

   (([3], Res), [ z = 1 / 2, z = -1 / 4]),

   (([4], Frm), factors_from_solution [z = 1 / 2, z = -1 / 4])]

\end{verbatim}      

      \par \noindent In particular that:

\begin{verbatim}

  (([3], Pbl), solve (-1 + -2 * z + 8 * z \<up> 2 = 0, z)),

\end{verbatim}

      \par \noindent Shows the equation which has been created in

      the program by: 

\begin{verbatim}

  "(denom::real) = get_denominator funterm;      " ^ 

    (* get_denominator *)

  "(equ::bool) = (denom = (0::real));            " ^

\end{verbatim}

      \noindent \ttfamily get\_denominator \normalfont has been evaluated successfully,

      but not\\ \ttfamily factors\_from\_solution.\normalfont

      So we stepwise compare with an analogous case, \ttfamily get\_denominator

      \normalfont successfully done above: We know that LIP evaluates

      expressions in the program by use of the \emph{prog_rls}, so we try to get

      the original \emph{prog_rls}.\\

\begin{verbatim}

  val {prog_rls,...} = MethodC.from_store ctxt ["SignalProcessing",

                            "Z_Transform",

                            "Inverse"];

\end{verbatim}

      \par \noindent Create 2 good example terms:

\begin{verbatim}

val SOME t1 =

  parseNEW ctxt "get_denominator ((111::real) / 222)";

val SOME t2 =

  parseNEW ctxt "factors_from_solution [(z::real)=1/2, z=-1/4]";

\end{verbatim}

      \par \noindent Rewrite the terms using prog_rls:\\

      \ttfamily \par \noindent rewrite\_set\_ thy true prog_rls t1;\\

        rewrite\_set\_ thy true prog_rls t2;\\

      \par \noindent \normalfont Now we see a difference: \texttt{t1} gives

      \texttt{SOME} but \texttt{t2} gives \texttt{NONE}. We look at the 

      \emph{prog_rls}:

\begin{verbatim}

  val prog_rls = 

    Rule_Set.Repeat{id = "srls_InverseZTransform",

        rules = [Eval("Rational.get_numerator",

                   eval_get_numerator "Rational.get_numerator"),

                 Eval("Partial_Fractions.factors_from_solution",

                   eval_factors_from_solution 

                     "Partial_Fractions.factors_from_solution")]}

\end{verbatim}                

      \par \noindent Here everthing is perfect. So the error can

      only be in the SML code of \ttfamily eval\_factors\_from\_solution.

      \normalfont We try to check the code with an existing test; since the 

      \emph{code} is in 

      \begin{center}\ttfamily src/Tools/isac/Knowledge/Partial\_Fractions.thy

      \normalfont\end{center}

      the \emph{test} should be in

      \begin{center}\ttfamily test/Tools/isac/Knowledge/partial\_fractions.sml

      \normalfont\end{center}

      \par \noindent After updating the function \ttfamily

      factors\_from\_solution \normalfont to a new version and putting a

      test-case to \ttfamily Partial\_Fractions.sml \normalfont we tried again

      to evaluate the term with the same result.

      \par We opened the test \ttfamily Test\_Isac.thy \normalfont and saw that

      everything is working fine. Also we checked that the test \ttfamily 

      partial\_fractions.sml \normalfont is used in \ttfamily Test\_Isac.thy 

      \normalfont

      \begin{center}use \ttfamily "Knowledge/partial\_fractions.sml"

      \normalfont \end{center}

      and \ttfamily Partial\_Fractions.thy \normalfont is part is part of

      {\sisac} by evaluating

\begin{verbatim}

  val thy = @{theory "Inverse_Z_Transform"};

\end{verbatim}

      After rebuilding {\sisac} again it worked.

\<close>

subsubsection \<open>Build Expression\<close>

text \<open>\noindent In {\sisac}'s TP-based programming language we can build

       expressions by:\\

       \ttfamily let s\_1 = Take numerator / (s\_1 * s\_2) \normalfont\<close>

ML \<open>

  (*

   * The main denominator is the multiplication of the denominators of

   * all partial fractions.

   *)

  val denominator' = HOLogic.mk_binop 

    \<^const_name>\<open>times\<close> (s_1', s_2') ;

  val SOME numerator = parseNEW ctxt "3::real";

  val expr' = HOLogic.mk_binop

    \<^const_name>\<open>divide\<close> (numerator, denominator');

  UnparseC.term expr';

\<close>

subsubsection \<open>Apply the Partial Fraction Decomposion Ansatz\<close>

text\<open>\noindent We use the Ansatz of the Partial Fraction Decomposition for our

      expression 2nd order. Follow up the calculation in 

      Section~\ref{sec:calc:ztrans} Step~03.\<close>

ML \<open>Context.theory_name thy = "Isac_Knowledge"\<close>

text\<open>\noindent We define two axiomatization, the first one is the main ansatz,

      the next one is just an equivalent transformation of the resulting

      equation. Both axiomatizations were moved to \ttfamily

      Partial\_Fractions.thy \normalfont and got their own rulesets. In later

      programs it is possible to use the rulesets and the machine will find

      the correct ansatz and equivalent transformation itself.\<close>

axiomatization where

  ansatz_2nd_order: "n / (a*b) = A/a + B/b" and

  equival_trans_2nd_order: "(n/(a*b) = A/a + B/b) = (n = A*b + B*a)"

text\<open>\noindent We use our \ttfamily ansatz\_2nd\_order \normalfont to rewrite

       our expression and get an equation with our expression on the left

       and the partial fractions of it on the right hand side.\<close>

ML \<open>

  val SOME (t1,_) = 

    rewrite_ @{theory} e_rew_ord Rule_Set.empty false 

             @{thm ansatz_2nd_order} expr';

  UnparseC.term t1; TermC.atom_trace_detail @{context} t1;

  val eq1 = HOLogic.mk_eq (expr', t1);

  UnparseC.term eq1;

\<close>

text\<open>\noindent Eliminate the denominators by multiplying the left and the

      right hand side of the equation with the main denominator. This is an

      simple equivalent transformation. Later on we use an own ruleset

      defined in \ttfamily Partial\_Fractions.thy \normalfont for doing this.

      Follow up the calculation in Section~\ref{sec:calc:ztrans} Step~04.\<close>

ML \<open>

  val SOME (eq2,_) = 

    rewrite_ @{theory} e_rew_ord Rule_Set.empty false 

             @{thm equival_trans_2nd_order} eq1;

  UnparseC.term eq2;

\<close>

text\<open>\noindent We use the existing ruleset \ttfamily norm\_Rational \normalfont 

     for simplifications on expressions.\<close>

ML \<open>

  val SOME (eq3,_) = rewrite_set_ @{theory} false norm_Rational eq2;

  UnparseC.term eq3;

  (*

   * ?A ?B not simplified

   *)

\<close>

text\<open>\noindent In Example~\ref{eg:gap} of my thesis I'm describing a problem about

      simplifications. The problem that we would like to have only a specific degree

      of simplification occurs right here, in the next step.\<close>

ML \<open>

  Rewrite.trace_on := false; (*true false*)

  val SOME fract1 =

    parseNEW ctxt "(z - 1/2)*(z - -1/4) * (A/(z - 1/2) + B/(z - -1/4))";

  (*

   * A B !

   *)

  val SOME (fract2,_) = 

    rewrite_set_ @{theory} false norm_Rational fract1;

  UnparseC.term fract2 = "(A + -2 * B + 4 * A * z + 4 * B * z) / 4";

  (*

   * UnparseC.term fract2 = "A * (1 / 4 + z) + B * (-1 / 2 + z)" 

   * would be more traditional...

   *)

\<close>

text\<open>\noindent We walk around this problem by generating our new equation first.\<close>

ML \<open>

  val (numerator, denominator) = HOLogic.dest_eq eq3;

  val eq3' = HOLogic.mk_eq (numerator, fract1);

  (*

   * A B !

   *)

  UnparseC.term eq3';

  (*

   * MANDATORY: simplify (and remove denominator) otherwise 3 = 0

   *)

  val SOME (eq3'' ,_) = 

    rewrite_set_ @{theory} false norm_Rational eq3';

  UnparseC.term eq3'';

\<close>

text\<open>\noindent Still working at {\sisac}\ldots\<close>

ML \<open>Context.theory_name thy = "Isac_Knowledge"\<close>

subsubsection \<open>Build a Rule-Set for the Ansatz\<close>

text \<open>\noindent The \emph{ansatz} rules violate the principle that each

       variable on the right-hand-side must also occur on the

       left-hand-side of the rule: A, B, etc. don't do that. Thus the

       rewriter marks these variables with question marks: ?A, ?B, etc.

       These question marks can be dropped by \ttfamily fun

       drop\_questionmarks\normalfont.\<close>

ML \<open>

  val ansatz_rls = prep_rls @{theory} (

    Rule_Set.Repeat {id = "ansatz_rls", preconds = [], rew_ord = ("dummy_ord",dummy_ord),

      asm_rls = Rule_Set.empty, prog_rls = Rule_Set.Empty, calc = [], errpatts = [],

      rules = [

        Thm ("ansatz_2nd_order",ThmC.numerals_to_Free @{thm ansatz_2nd_order}),

        Thm ("equival_trans_2nd_order",ThmC.numerals_to_Free @{thm equival_trans_2nd_order})

              ], 

      program = Empty_Prog});

\<close>

text\<open>\noindent We apply the ruleset\ldots\<close>

ML \<open>

  val SOME (ttttt,_) = 

    rewrite_set_ @{theory} false ansatz_rls expr';

\<close>

text\<open>\noindent And check the output\ldots\<close>

ML \<open>

  UnparseC.term expr' = "3 / ((z - 1 / 2) * (z - -1 / 4))";

  UnparseC.term ttttt = "?A / (z - 1 / 2) + ?B / (z - -1 / 4)";

\<close>

subsubsection \<open>Get the First Coefficient\<close>

text\<open>\noindent Now it's up to get the two coefficients A and B, which will be

      the numerators of our partial fractions. Continue following up the 

      Calculation in Section~\ref{sec:calc:ztrans} Subproblem~1.\<close>

text\<open>\noindent To get the first coefficient we substitute $z$ with the first

      zero-point we determined in Section~\ref{sec:solveq}.\<close>

ML \<open>

  val SOME (eq4_1,_) =

    rewrite_terms_ @{theory} e_rew_ord Rule_Set.empty [s_1] eq3'';

  UnparseC.term eq4_1;

  val SOME (eq4_2,_) =

    rewrite_set_ @{theory} false norm_Rational eq4_1;

  UnparseC.term eq4_2;

  val fmz = ["equality (3=3*A/(4::real))", "solveFor A", "solutions L"];

  val (dI',pI',mI') =("Isac_Knowledge", ["univariate", "equation"], ["no_met"]);

  (*

   * Solve the simple linear equation for A:

   * Return eq, not list of eq's

   *)

  val (p,_,fa,nxt,_,pt) = Test_Code.init_calc @{context} [(fmz, (dI',pI',mI'))];

  val (p,_,fa,nxt,_,pt) = me nxt p [] pt;

    (*Add_Given "equality (3=3*A/4)"*)

  val (p,_,fa,nxt,_,pt) = me nxt p [] pt;

    (*Add_Given "solveFor A"*)

  val (p,_,fa,nxt,_,pt) = me nxt p [] pt; 

    (*Add_Find "solutions L"*)

  val (p,_,fa,nxt,_,pt) = me nxt p [] pt;

    (*Specify_Theory "Isac_Knowledge"*)

  val (p,_,fa,nxt,_,pt) = me nxt p [] pt;

    (*Specify_Problem ["normalise", "polynomial",

                       "univariate", "equation"])*)

  val (p,_,fa,nxt,_,pt) = me nxt p [] pt;

    (* Specify_Method["PolyEq", "normalise_poly"]*)

  val (p,_,fa,nxt,_,pt) = me nxt p [] pt;

    (*Apply_Method["PolyEq", "normalise_poly"]*)

  val (p,_,fa,nxt,_,pt) = me nxt p [] pt;

    (*Rewrite ("all_left", "PolyEq.all_left")*)

  val (p,_,fa,nxt,_,pt) = me nxt p [] pt;

    (*Rewrite_Set_Inst(["(''bdv'',A)"],"make_ratpoly_in")*)

  val (p,_,fa,nxt,_,pt) = me nxt p [] pt;

    (*Rewrite_Set "polyeq_simplify"*)

  val (p,_,fa,nxt,_,pt) = me nxt p [] pt; 

  val (p,_,fa,nxt,_,pt) = me nxt p [] pt; 

  val (p,_,fa,nxt,_,pt) = me nxt p [] pt;

    (*Add_Given "equality (3 + -3 / 4 * A =0)"*)

  val (p,_,fa,nxt,_,pt) = me nxt p [] pt;

    (*Add_Given "solveFor A"*)

  val (p,_,fa,nxt,_,pt) = me nxt p [] pt;

    (*Add_Find "solutions A_i"*)

  val (p,_,fa,nxt,_,pt) = me nxt p [] pt; 

  val (p,_,fa,nxt,_,pt) = me nxt p [] pt; 

  val (p,_,fa,nxt,_,pt) = me nxt p [] pt; 

  val (p,_,fa,nxt,_,pt) = me nxt p [] pt; 

    (*Apply_Method ["PolyEq", "solve_d1_polyeq_equation"]*)

  val (p,_,fa,nxt,_,pt) = me nxt p [] pt;

    (*Rewrite_Set_Inst(["(''bdv'',A)"],"d1_polyeq_simplify")*)

  val (p,_,fa,nxt,_,pt) = me nxt p [] pt;

    (*Rewrite_Set "polyeq_simplify"*)

  val (p,_,fa,nxt,_,pt) = me nxt p [] pt;

    (*Rewrite_Set "norm_Rational_parenthesized"*)

  val (p,_,fa,nxt,_,pt) = me nxt p [] pt;

    (*Or_to_List*)

  val (p,_,fa,nxt,_,pt) = me nxt p [] pt;

    (*Check_elementwise "Assumptions"*)

  val (p,_,fa,nxt,_,pt) = me nxt p [] pt;

    (*Check_Postcond ["degree_1", "polynomial",

                      "univariate", "equation"]*)

  val (p,_,fa,nxt,_,pt) = me nxt p [] pt;

    (*Check_Postcond ["normalise", "polynomial",

                      "univariate", "equation"]*)

  val (p,_,fa,nxt,_,pt) = me nxt p [] pt;

    (*End_Proof'*)

  f2str fa;

\<close>

subsubsection \<open>Get Second Coefficient\<close>

text\<open>\noindent With the use of \texttt{thy} we check which theories the 

      interpreter knows.\<close>

ML \<open>thy\<close>

text\<open>\noindent To get the second coefficient we substitute $z$ with the second

      zero-point we determined in Section~\ref{sec:solveq}.\<close>

ML \<open>

  val SOME (eq4b_1,_) =

    rewrite_terms_ @{theory} e_rew_ord Rule_Set.empty [s_2] eq3'';

  UnparseC.term eq4b_1;

  val SOME (eq4b_2,_) =

    rewrite_set_ @{theory} false norm_Rational eq4b_1;

  UnparseC.term eq4b_2;

  val fmz = ["equality (3= -3*B/(4::real))", "solveFor B", "solutions L"];

  val (dI',pI',mI') =("Isac_Knowledge", ["univariate", "equation"], ["no_met"]);

  val (p,_,fb,nxt,_,pt) = Test_Code.init_calc @{context} [(fmz, (dI',pI',mI'))];

  val (p,_,fb,nxt,_,pt) = me nxt p [] pt;

  val (p,_,fb,nxt,_,pt) = me nxt p [] pt;

  val (p,_,fb,nxt,_,pt) = me nxt p [] pt;

  val (p,_,fb,nxt,_,pt) = me nxt p [] pt;

  val (p,_,fb,nxt,_,pt) = me nxt p [] pt;

  val (p,_,fb,nxt,_,pt) = me nxt p [] pt;

  val (p,_,fb,nxt,_,pt) = me nxt p [] pt;

  val (p,_,fb,nxt,_,pt) = me nxt p [] pt;

  val (p,_,fb,nxt,_,pt) = me nxt p [] pt;

  val (p,_,fb,nxt,_,pt) = me nxt p [] pt;

  val (p,_,fb,nxt,_,pt) = me nxt p [] pt;

  val (p,_,fb,nxt,_,pt) = me nxt p [] pt;

  val (p,_,fb,nxt,_,pt) = me nxt p [] pt;

  val (p,_,fb,nxt,_,pt) = me nxt p [] pt;

  val (p,_,fb,nxt,_,pt) = me nxt p [] pt;

  val (p,_,fb,nxt,_,pt) = me nxt p [] pt;

  val (p,_,fb,nxt,_,pt) = me nxt p [] pt;

  val (p,_,fb,nxt,_,pt) = me nxt p [] pt;

  val (p,_,fb,nxt,_,pt) = me nxt p [] pt;

  val (p,_,fb,nxt,_,pt) = me nxt p [] pt;

  val (p,_,fb,nxt,_,pt) = me nxt p [] pt;

  val (p,_,fb,nxt,_,pt) = me nxt p [] pt;

  val (p,_,fb,nxt,_,pt) = me nxt p [] pt;

  val (p,_,fb,nxt,_,pt) = me nxt p [] pt;

  val (p,_,fb,nxt,_,pt) = me nxt p [] pt;

  val (p,_,fb,nxt,_,pt) = me nxt p [] pt;

  val (p,_,fb,nxt,_,pt) = me nxt p [] pt; 

  f2str fb;

\<close>

text\<open>\noindent We compare our results with the where_ calculated upshot.\<close>

ML \<open>

  if f2str fa = "[A = 4]" then () else error "part.fract. eq4_1";

  if f2str fb = "[B = -4]" then () else error "part.fract. eq4_1";

\<close>

section \<open>Implement the Specification and the MethodC \label{spec-meth}\<close>

text\<open>\noindent Now everything we need for solving the problem has been

      tested out. We now start by creating new nodes for our methods and

      further on our new program in the interpreter.\<close>

subsection\<open>Define the Field Descriptions for the 

            Specification\label{sec:deffdes}\<close>

text\<open>\noindent We define the fields \em filterExpression \normalfont and

      \em stepResponse \normalfont both as equations, they represent the in- and

      output of the program.\<close>

consts

  filterExpression  :: "bool => una"

  stepResponse      :: "bool => una"

subsection\<open>Define the Specification\<close>

text\<open>\noindent The next step is defining the specifications as nodes in the

      designated part. We have to create the hierarchy node by node and start

      with \em SignalProcessing \normalfont and go on by creating the node

      \em Z\_Transform\normalfont.\<close>

setup \<open>Know_Store.add_pbls

  [Problem.prep_input @{theory} "pbl_SP" [] Problem.id_empty (["SignalProcessing"], [], Rule_Set.empty, NONE, []),

    Problem.prep_input @{theory} "pbl_SP_Ztrans" [] Problem.id_empty

      (["Z_Transform", "SignalProcessing"], [], Rule_Set.empty, NONE, [])]\<close>

text\<open>\noindent For the suddenly created node we have to define the input

       and output parameters. We already prepared their definition in

       Section~\ref{sec:deffdes}.\<close>

setup \<open>Know_Store.add_pbls

  [Problem.prep_input @{theory} "pbl_SP_Ztrans_inv" [] Problem.id_empty

      (["Inverse", "Z_Transform", "SignalProcessing"],

        [("#Given" ,["filterExpression X_eq"]),

          ("#Find", ["stepResponse n_eq"])],

        Rule_Set.append_rules "empty" Rule_Set.empty [(*for preds in where_*)],

        NONE,

        [["SignalProcessing", "Z_Transform", "Inverse"]])]\<close>

ML \<open>

  Test_Tool.show_ptyps() ();

  Problem.from_store ["Inverse", "Z_Transform", "SignalProcessing"];

\<close>

subsection \<open>Define Name and Signature for the MethodC\<close>

text\<open>\noindent As a next step we store the definition of our new method as a

      constant for the interpreter.\<close>

consts

  InverseZTransform :: "[bool, bool] => bool"

    ("((Program InverseZTransform (_ =))// (_))" 9)

subsection \<open>Setup Parent Nodes in Hierarchy of MethodC\label{sec:cparentnode}\<close>

text\<open>\noindent Again we have to generate the nodes step by step, first the

      parent node and then the originally \em Z\_Transformation 

      \normalfont node. We have to define both nodes first with an empty script

      as content.\<close>

setup \<open>Know_Store.add_mets

  [MethodC.prep_input @{theory} "met_SP" [] e_metID

      (["SignalProcessing"], [],

        {rew_ord="tless_true", rls'= Rule_Set.empty, calc = [], prog_rls = Rule_Set.empty, where_rls = Rule_Set.empty, crls = Rule_Set.empty,

          errpats = [], rew_rls = Rule_Set.empty},

        "empty_script"),

    MethodC.prep_input @{theory} "met_SP_Ztrans" [] e_metID

      (["SignalProcessing", "Z_Transform"], [],

        {rew_ord="tless_true", rls'= Rule_Set.empty, calc = [], prog_rls = Rule_Set.empty, where_rls = Rule_Set.empty, crls = Rule_Set.empty,

          errpats = [], rew_rls = Rule_Set.empty},

        "empty_script")]

\<close>

text\<open>\noindent After we generated both nodes, we can fill the containing

      script we want to implement later. First we define the specifications

      of the script in e.g. the in- and output.\<close>

setup \<open>Know_Store.add_mets

  [MethodC.prep_input thy "met_SP_Ztrans_inv" [] e_metID

      (["SignalProcessing", "Z_Transform", "Inverse"], 

        [("#Given" ,["filterExpression X_eq", "boundVariable X_z"]),

          ("#Find", ["stepResponse n_eq"])],

        {rew_ord="tless_true", rls'= Rule_Set.empty, calc = [], prog_rls = Rule_Set.empty, where_rls = Rule_Set.empty, crls = Rule_Set.empty,

          errpats = [], rew_rls = Rule_Set.empty},

        "empty_script")]

\<close>

text\<open>\noindent After we stored the definition we can start implementing the

      script itself. As a first try we define only three rows containing one

      simple operation.\<close>

setup \<open>Know_Store.add_mets

  [MethodC.prep_input thy "met_SP_Ztrans_inv" [] e_metID

      (["SignalProcessing", "Z_Transform", "Inverse"], 

        [("#Given" , ["filterExpression X_eq", "boundVariable X_z"]),

          ("#Find", ["stepResponse n_eq"])],

        {rew_ord="tless_true", rls'= Rule_Set.empty, calc = [], prog_rls = Rule_Set.empty, where_rls = Rule_Set.empty, crls = Rule_Set.empty,

          errpats = [], rew_rls = Rule_Set.empty},

        "Program InverseZTransform (Xeq::bool) =" ^ (*TODO boundVariable X_z*)

          " (let X = Take Xeq;" ^

          "      X = Rewrite ruleZY X" ^

          "  in X)")]

\<close>

text\<open>\noindent Check if the method has been stored correctly\ldots\<close>

ML \<open>

  show_mets(); 

\<close>

text\<open>\noindent If yes we can get the method by stepping backwards through

      the hierarchy.\<close>

ML \<open>

  MethodC.from_store ctxt ["SignalProcessing", "Z_Transform", "Inverse"];

\<close>

section \<open>Program in TP-based language \label{prog-steps}\<close>

text\<open>\noindent We start stepwise expanding our program. The script is a

      simple string containing several manipulation instructions.

      \par The first script we try contains no instruction, we only test if

      building scripts that way work.\<close>

subsection \<open>Stepwise Extend the Program\<close>

ML \<open>

  val str =