(* Title:  Test_Z_Transform

   Author: Jan Rocnik

   (c) copyright due to lincense terms.

12345678901234567890123456789012345678901234567890123456789012345678901234567890

        10        20        30        40        50        60        70        80

*)

theory Inverse_Z_Transform imports PolyEq DiffApp Partial_Fractions begin

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: "c * (z / (z - \<alpha>)) = c * \<alpha>^^^n * u [n]" and

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

  rule6: "|| z || > 1 ==> z/(z - 1)^^^2 = n * u [n]" (*and

  rule42: "(a * (z/(z-b)) + c * (z/(z-d))) = (a * b^^^n * u [n] + c * d^^^n * u [n])"*)

axiomatization where

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

  ruleYZ: "(a/b + c/d) = (a*(z/b) + c*(z/d))" 

subsection\<open>Define the Field Descriptions for the specification\<close>

consts

  filterExpression  :: "bool => una"

  stepResponse      :: "bool => una"

ML \<open>

val inverse_z = prep_rls'(

  Rule.Rls {id = "inverse_z", preconds = [], rew_ord = ("dummy_ord",Rule.dummy_ord), 

	  erls = Rule.Erls, srls = Rule.Erls, calc = [], errpatts = [],

	  rules = 

	   [

    Rule.Thm ("rule4", @{thm rule4})

	   ], 

	 scr = Rule.EmptyScr});

\<close>

text \<open>store the rule set for math engine\<close>

setup \<open>KEStore_Elems.add_rlss [("inverse_z", (Context.theory_name @{theory}, inverse_z))]\<close>

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

ML \<open>

val thy = @{theory};

\<close>

setup \<open>KEStore_Elems.add_pbts

  [(Specify.prep_pbt thy "pbl_SP" [] Celem.e_pblID (["SignalProcessing"], [], Rule.e_rls, NONE, [])),

    (Specify.prep_pbt thy "pbl_SP_Ztrans" [] Celem.e_pblID

      (["Z_Transform","SignalProcessing"], [], Rule.e_rls, NONE, [])),

    (Specify.prep_pbt thy "pbl_SP_Ztrans_inv" [] Celem.e_pblID

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

        (*^ capital letter breaks coding standard

          because "inverse" = Const ("Rings.inverse_class.inverse", ..*)

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

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

        Rule.append_rls "e_rls" Rule.e_rls [(*for preds in where_*)], NONE, 

        [["SignalProcessing","Z_Transform","Inverse"]])),

    (Specify.prep_pbt thy "pbl_SP_Ztrans_inv" [] Celem.e_pblID

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

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

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

        Rule.append_rls "e_rls" Rule.e_rls [(*for preds in where_*)], NONE, 

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

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

consts

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

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

subsection \<open>Setup Parent Nodes in Hierarchy of Method\<close>

ML \<open>val thy = @{theory}; (*latest version of thy required*)\<close>

setup \<open>KEStore_Elems.add_mets

    [Specify.prep_met thy "met_SP" [] Celem.e_metID

      (["SignalProcessing"], [],

        {rew_ord'="tless_true", rls'= Rule.e_rls, calc = [], srls = Rule.e_rls, prls = Rule.e_rls, crls = Rule.e_rls,

          errpats = [], nrls = Rule.e_rls}, "empty_script"),

    Specify.prep_met thy "met_SP_Ztrans" [] Celem.e_metID

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

        {rew_ord'="tless_true", rls'= Rule.e_rls, calc = [], srls = Rule.e_rls, prls = Rule.e_rls, crls = Rule.e_rls,

          errpats = [], nrls = Rule.e_rls}, "empty_script")]

\<close>

(*ok

partial_function (tailrec) inverse_ztransform :: "bool \<Rightarrow> bool"

  where

"inverse_ztransform X_eq =                                           \<comment> \<open>(1/z) instead of z ^^^ -1\<close>                

 (let X = Take X_eq;                                                                

      X' = Rewrite ''ruleZY'' False X;                                         \<comment> \<open>z * denominator\<close>                          

      X' = (Rewrite_Set ''norm_Rational'' False) X';                                  \<comment> \<open>simplify\<close>                   

      funterm = Take (rhs X');                                \<comment> \<open>drop X' z = for equation solving\<close>                 

      denom = (Rewrite_Set ''partial_fraction'' False) funterm;                \<comment> \<open>get_denominator\<close> 

      equ = (denom = (0::real));                                                    

      fun_arg = Take (lhs X');                                                      

      arg = (Rewrite_Set ''partial_fraction'' False) X';                     \<comment> \<open>get_argument TODO\<close>      

      L_L = SubProblem (''Test'', [''LINEAR'',''univariate'',''equation'',''test''],         

                [''Test'',''solve_linear'']) [BOOL equ, STRING ''z'']              \<comment> \<open>PROG string\<close>

  in X) "

*)

setup \<open>KEStore_Elems.add_mets

    [Specify.prep_met thy "met_SP_Ztrans_inv" [] Celem.e_metID

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

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

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

        {rew_ord'="tless_true", rls'= Rule.e_rls, calc = [], srls = Rule.e_rls, prls = Rule.e_rls, crls = Rule.e_rls,

          errpats = [], nrls = Rule.e_rls},

        "Script InverseZTransform (X_eq::bool) =" ^ (*(1/z) instead of z ^^^ -1*)

          " (let X = Take X_eq;" ^

          "      X' = Rewrite ''ruleZY'' False X;" ^ (*z * denominator*)

          "      X' = (Rewrite_Set ''norm_Rational'' False) X';" ^ (*simplify*)

          "      funterm = Take (rhs X');" ^ (*drop X' z = for equation solving*)

          "      denom = (Rewrite_Set ''partial_fraction'' False) funterm;" ^ (*get_denominator*)

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

          "      fun_arg = Take (lhs X');" ^

          "      arg = (Rewrite_Set ''partial_fraction'' False) X';" ^ (*get_argument TODO*)

          "      (L_L::bool list) =                                    " ^

          "            (SubProblem (''Test'',                            " ^

          "                         [''LINEAR'',''univariate'',''equation'',''test'']," ^

          "                         [''Test'',''solve_linear''])              " ^

          "                        [BOOL equ, REAL z])              " ^

          "  in X)")]

\<close>

(*

Type unification failed: Clash of types "bool" and "_ itself"

Type error in application: incompatible operand type

Operator:  Let (Take X_eq) :: (??'a itself \<Rightarrow> ??'b) \<Rightarrow> ??'b

Operand:

  \<lambda>X. let X' = Rewrite ''ruleZY'' ...

:

:partial_function (tailrec) inverse_ztransform2 :: "bool \<Rightarrow> bool"

  where

"inverse_ztransform X_eq =                                          \<comment> \<open>(1/z) instead of z ^^^ -1\<close>

  (let X = Take X_eq;

      X' = Rewrite ''ruleZY'' False X;                                        \<comment> \<open>z * denominator\<close>

      (num_orig::real) = get_numerator (rhs X');                                  

      X' = (Rewrite_Set ''norm_Rational'' False) X';                                 \<comment> \<open>simplify\<close>

      (X'_z::real) = lhs X';                                                      

      (zzz::real) = argument_in X'_z;                                             

      (funterm::real) = rhs X';                              \<comment> \<open>drop X' z = for equation solving\<close>

      (denom::real) = get_denominator funterm;                                \<comment> \<open>get_denominator\<close>

      (num::real) = get_numerator funterm;                                      \<comment> \<open>get_numerator\<close>

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

      (L_L::bool list) = (SubProblem (''PolyEq'',                                 

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

         [''no_met''])                                                            

         [BOOL equ, REAL zzz]);                                                   

      (facs::real) = factors_from_solution L_L;                                   

      (eql::real) = Take (num_orig / facs); \<comment> \<open>---\<close>

      (eqr::real) = (Try (Rewrite_Set ''ansatz_rls'' False)) eql; \<comment> \<open>---\<close>

      (eq::bool) = Take (eql = eqr);                    \<comment> \<open>Maybe possible to use HOLogic.mk_eq ??\<close>

      eq = (Try (Rewrite_Set ''equival_trans'' False)) eq; \<comment> \<open>---\<close>

      eq = drop_questionmarks eq;                                                 

      (z1::real) = (rhs (NTH 1 L_L)); \<comment> \<open>prepare equation for a - eq_a therefor substitute z with solution 1 - z1\<close>

      (z2::real) = (rhs (NTH 2 L_L)); \<comment> \<open>---\<close>

      (eq_a::bool) = Take eq;                                                     

      eq_a = (Substitute [zzz=z1]) eq;                                            

      eq_a = (Rewrite_Set ''norm_Rational'' False) eq_a;                          

      (sol_a::bool list) =                                                        

                 (SubProblem (''Isac'',                                           

                              [''univariate'',''equation''],[''no_met''])         

                              [BOOL eq_a, REAL (A::real)]);                       

      (a::real) = (rhs(NTH 1 sol_a)); \<comment> \<open>---\<close>

      (eq_b::bool) = Take eq;                                                     

      eq_b =  (Substitute [zzz=z2]) eq_b;                                         

      eq_b = (Rewrite_Set ''norm_Rational'' False) eq_b;                          

      (sol_b::bool list) =                                                        

                 (SubProblem (''Isac'',                                           

                              [''univariate'',''equation''],[''no_met''])         

                              [BOOL eq_b, REAL (B::real)]);                       

      (b::real) = (rhs(NTH 1 sol_b)); \<comment> \<open>---\<close>

      eqr = drop_questionmarks eqr;                                               

      (pbz::real) = Take eqr;                                                     

      pbz = ((Substitute [A=a, B=b]) pbz); \<comment> \<open>---\<close>

      pbz = Rewrite ''ruleYZ'' False pbz;                                         

      pbz = drop_questionmarks pbz; \<comment> \<open>---\<close>

      (X_z::bool) = Take (X_z = pbz);                                             

      (n_eq::bool) = (Rewrite_Set ''inverse_z'' False) X_z;                       

      n_eq = drop_questionmarks n_eq                                              

in n_eq)"

*)

setup \<open>KEStore_Elems.add_mets

    [Specify.prep_met thy "met_SP_Ztrans_inv" [] Celem.e_metID

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

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

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

        {rew_ord'="tless_true", rls'= Rule.e_rls, calc = [], srls = srls_partial_fraction, prls = Rule.e_rls,

          crls = Rule.e_rls, errpats = [], nrls = Rule.e_rls},

        "Script InverseZTransform (X_eq::bool) =                        "^

           (*(1/z) instead of z ^^^ -1*)

           "(let X = Take X_eq;                                            "^

           "      X' = Rewrite ''ruleZY'' False X;                             "^

           (*z * denominator*)

           "      (num_orig::real) = get_numerator (rhs X');               "^

           "      X' = (Rewrite_Set ''norm_Rational'' False) X';               "^

           (*simplify*)

           "      (X'_z::real) = lhs X';                                   "^

           "      (zzz::real) = argument_in X'_z;                          "^

           "      (funterm::real) = rhs X';                                "^

           (*drop X' z = for equation solving*)

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

           (*get_denominator*)

           "      (num::real) = get_numerator funterm;                     "^

           (*get_numerator*)

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

           "      (L_L::bool list) = (SubProblem (''PolyEq'',                 "^

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

           "         [''no_met''])                                             "^

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

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

           "      (eql::real) = Take (num_orig / facs);                    "^ 

           "      (eqr::real) = (Try (Rewrite_Set ''ansatz_rls'' False)) eql;  "^

           "      (eq::bool) = Take (eql = eqr);                           "^

           (*Maybe possible to use HOLogic.mk_eq ??*)

           "      eq = (Try (Rewrite_Set ''equival_trans'' False)) eq;         "^ 

           "      eq = drop_questionmarks eq;                              "^

           "      (z1::real) = (rhs (NTH 1 L_L));                          "^

           (* 

            * prepare equation for a - eq_a

            * therefor substitute z with solution 1 - z1

            *)

           "      (z2::real) = (rhs (NTH 2 L_L));                          "^

           "      (eq_a::bool) = Take eq;                                  "^

           "      eq_a = (Substitute [zzz=z1]) eq;                         "^

           "      eq_a = (Rewrite_Set ''norm_Rational'' False) eq_a;           "^

           "      (sol_a::bool list) =                                     "^

           "                 (SubProblem (''Isac'',                           "^

           "                              [''univariate'',''equation''],[''no_met''])  "^

           "                              [BOOL eq_a, REAL (A::real)]);    "^

           "      (a::real) = (rhs(NTH 1 sol_a));                          "^

           "      (eq_b::bool) = Take eq;                                  "^

           "      eq_b =  (Substitute [zzz=z2]) eq_b;                      "^

           "      eq_b = (Rewrite_Set ''norm_Rational'' False) eq_b;           "^

           "      (sol_b::bool list) =                                     "^

           "                 (SubProblem (''Isac'',                           "^

           "                              [''univariate'',''equation''],[''no_met''])  "^

           "                              [BOOL eq_b, REAL (B::real)]);    "^

           "      (b::real) = (rhs(NTH 1 sol_b));                          "^

           "      eqr = drop_questionmarks eqr;                            "^

           "      (pbz::real) = Take eqr;                                  "^

           "      pbz = ((Substitute [A=a, B=b]) pbz);                     "^

           "      pbz = Rewrite ''ruleYZ'' False pbz;                          "^

           "      pbz = drop_questionmarks pbz;                            "^

           "      (X_z::bool) = Take (X_z = pbz);                          "^

           "      (n_eq::bool) = (Rewrite_Set ''inverse_z'' False) X_z;        "^

           "      n_eq = drop_questionmarks n_eq                           "^

           "in n_eq)")]

\<close>

(* same error as in         inverse_ztransform2

:partial_function (tailrec) inverse_ztransform3 :: "bool \<Rightarrow> bool"

  where

"inverse_ztransform X_eq =                                               

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

(let X = Take X_eq;                                                                 

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

  X' = Rewrite ''ruleZY'' False X;                                                  

(*            ?X' z*)                                                               

  (X'_z::real) = lhs X';                                                            

(*            z *)                                                                  

  (zzz::real) = argument_in X'_z;                                                   

(*            3 / (z * (z - 1 / 4 + -1 / 8 * (1 / z)))*)                            

  (funterm::real) = rhs X';                                                         

(*-----*)                                                                           

  (pbz::real) = (SubProblem (''Isac'',                                              

    [''partial_fraction'',''rational'',''simplification''],                         

    [''simplification'',''of_rationals'',''to_partial_fraction''])                  

(*([2], Res), 4 / (z - 1 / 2) + -4 / (z - -1 / 4)*)                                 

    [REAL funterm, REAL zzz]);                                                      

(*-----*)                                                                           

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

  (pbz_eq::bool) = Take (X'_z = pbz);                                               

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

  pbz_eq = Rewrite ''ruleYZ'' False pbz_eq;                                         

(*               4 * (z / (z - 1 / 2)) + -4 * (z / (z - -1 / 4))*)                  

  pbz_eq = drop_questionmarks pbz_eq;                                               

(*([4], Frm), X_z = 4 * (z / (z - 1 / 2)) + -4 * (z / (z - -1 / 4))*)               

  (X_zeq::bool) = Take (X_z = rhs pbz_eq);                                          

(*([4], Res), X_z = 4 * (1 / 2) ^^^ ?n * ?u [?n] + -4 * (-1 / 4) ^^^ ?n * ?u [?n]*)

  n_eq = (Rewrite_Set ''inverse_z'' False) X_zeq;                                   

(*            X_z = 4 * (1 / 2) ^^^ n * u [n] + -4 * (-1 / 4) ^^^ n * u [n]*)

  n_eq = drop_questionmarks n_eq                                                    

(*([], Res), X_z = 4 * (1 / 2) ^^^ n * u [n] + -4 * (-1 / 4) ^^^ n * u [n]*)

in n_eq)                                                                            "

*)

setup \<open>KEStore_Elems.add_mets

    [Specify.prep_met thy "met_SP_Ztrans_inv_sub" [] Celem.e_metID

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

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

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

        {rew_ord'="tless_true", rls'= Rule.e_rls, calc = [],

          srls = Rule.Rls {id="srls_partial_fraction", 

              preconds = [], rew_ord = ("termlessI",termlessI),

              erls = Rule.append_rls "erls_in_srls_partial_fraction" Rule.e_rls

                  [(*for asm in NTH_CONS ...*)

                    Rule.Calc ("Orderings.ord_class.less",eval_equ "#less_"),

                    (*2nd NTH_CONS pushes n+-1 into asms*)

                    Rule.Calc("Groups.plus_class.plus", eval_binop "#add_")], 

              srls = Rule.Erls, calc = [], errpatts = [],

              rules = [Rule.Thm ("NTH_CONS", @{thm NTH_CONS}),

                  Rule.Calc ("Groups.plus_class.plus", eval_binop "#add_"),

                  Rule.Thm ("NTH_NIL", @{thm NTH_NIL}),

                  Rule.Calc ("Tools.lhs", Tools.eval_lhs "eval_lhs_"),

                  Rule.Calc ("Tools.rhs", Tools.eval_rhs"eval_rhs_"),

                  Rule.Calc ("Atools.argument'_in", eval_argument_in "Atools.argument'_in"),

                  Rule.Calc ("Rational.get_denominator", eval_get_denominator "#get_denominator"),

                  Rule.Calc ("Rational.get_numerator", eval_get_numerator "#get_numerator"),

                  Rule.Calc ("Partial_Fractions.factors_from_solution",

                    eval_factors_from_solution "#factors_from_solution"),

                  Rule.Calc("Partial_Fractions.drop_questionmarks", eval_drop_questionmarks "#drop_?")],

              scr = Rule.EmptyScr},

          prls = Rule.e_rls, crls = Rule.e_rls, errpats = [], nrls = norm_Rational},

        (*([], Frm), Problem (Isac, [Inverse, Z_Transform, SignalProcessing])*)

        "Script InverseZTransform (X_eq::bool) =            "^

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

          "(let X = Take X_eq;                                "^

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

          "  X' = Rewrite ''ruleZY'' False X;                     "^

          (*            ?X' z*)

          "  (X'_z::real) = lhs X';                           "^

          (*            z *)

          "  (zzz::real) = argument_in X'_z;                  "^

          (*            3 / (z * (z - 1 / 4 + -1 / 8 * (1 / z)))*)

          "  (funterm::real) = rhs X';                        "^

          "  (pbz::real) = (SubProblem (''Isac'',                "^

          "    [''partial_fraction'',''rational'',''simplification''],    "^

          "    [''simplification'',''of_rationals'',''to_partial_fraction'']) "^

          (*([2], Res), 4 / (z - 1 / 2) + -4 / (z - -1 / 4)*)

          "    [REAL funterm, REAL zzz]);                     "^

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

          "  (pbz_eq::bool) = Take (X'_z = pbz);              "^

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

          "  pbz_eq = Rewrite ''ruleYZ'' False pbz_eq;            "^

          (*               4 * (z / (z - 1 / 2)) + -4 * (z / (z - -1 / 4))*)

          "  pbz_eq = drop_questionmarks pbz_eq;              "^

          (*([4], Frm), X_z = 4 * (z / (z - 1 / 2)) + -4 * (z / (z - -1 / 4))*)

          "  (X_zeq::bool) = Take (X_z = rhs pbz_eq);         "^

          (*([4], Res), X_z = 4 * (1 / 2) ^^^ ?n * ?u [?n] + -4 * (-1 / 4) ^^^ ?n * ?u [?n]*)

          "  n_eq = (Rewrite_Set ''inverse_z'' False) X_zeq;      "^

          (*            X_z = 4 * (1 / 2) ^^^ n * u [n] + -4 * (-1 / 4) ^^^ n * u [n]*)

          "  n_eq = drop_questionmarks n_eq                   "^

          (*([], Res), X_z = 4 * (1 / 2) ^^^ n * u [n] + -4 * (-1 / 4) ^^^ n * u [n]*)

          "in n_eq)")]

\<close>

end