(* Title:  Inverse_Z_Transform

    Author: Jan Rocnik

    (c) copyright due to lincense terms.

 *)

 theory Inverse_Z_Transform imports PolyEq DiffApp Partial_Fractions begin

 axiomatization where       \<comment> \<open>TODO: new variables on the rhs enforce replacement by substitution\<close>

   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> \<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]" (*and

   rule42: "(a * (z/(z-b)) + c * (z/(z-d))) = (a * b \<up> n * u [n] + c * d \<up> n * u [n])"*)

 axiomatization where

 (*ruleZY: "(X z = a / b) = (d_d z X = a / (z * b))"         ..looks better, but types are flawed*)

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

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

   ruleYZa: "(a / b + c / d) = (a * (z / b) + c * (z / d))"        \<comment> \<open>that is what students learn\<close>

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

 consts

   filterExpression  :: "bool => una"

   stepResponse      :: "bool => una"    \<comment> \<open>TODO: unused, "u [n]" is introduced by rule1..6 above\<close>

 ML \<open>

 val inverse_z = prep_rls'(

   Rule_Def.Repeat {id = "inverse_z", preconds = [], rew_ord = ("dummy_ord",Rewrite_Ord.dummy_ord), 

 	  erls = Rule_Set.Empty, srls = Rule_Set.Empty, calc = [], errpatts = [],

 	  rules = 

 	   [

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

 	   ], 

 	 scr = Rule.Empty_Prog});

 \<close>

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

 rule_set_knowledge inverse_z = inverse_z

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

 setup \<open>KEStore_Elems.add_pbts

   [(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, [])),

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

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

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

           ("#Find"  ,["stepResponse n_eq"])], \<comment> \<open>TODO: unused, "u [n]" is introduced by rule1..6\<close>

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

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

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

 setup \<open>KEStore_Elems.add_mets

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

       (["SignalProcessing"], [],

         {rew_ord'="tless_true", rls'= Rule_Set.empty, calc = [], srls = Rule_Set.empty, prls = Rule_Set.empty, crls = Rule_Set.empty,

           errpats = [], nrls = Rule_Set.empty}, @{thm refl}),

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

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

         {rew_ord'="tless_true", rls'= Rule_Set.empty, calc = [], srls = Rule_Set.empty, prls = Rule_Set.empty, crls = Rule_Set.empty,

           errpats = [], nrls = Rule_Set.empty}, @{thm refl})]

 \<close>

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

   where

 "inverse_ztransform X_eq X_z = (

   let

     X = Take X_eq;

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

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

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

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

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

     fun_arg = Take (lhs X');

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

     (L_L::bool list) = \<comment> \<open>'bool list' inhibits:

                 WARNING: Additional type variable(s) in specification of inverse_ztransform: 'a\<close>

       SubProblem (''Test'', [''LINEAR'',''univariate'',''equation'',''test''], [''Test'',''solve_linear''])

         [BOOL equ, REAL X_z]

   in X) "

 setup \<open>KEStore_Elems.add_mets

     [MethodC.prep_input @{theory} "met_SP_Ztrans_inv" [] MethodC.id_empty

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

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

           ("#Find"  ,["stepResponse n_eq"])], \<comment> \<open>TODO: unused, "u [n]" is introduced by rule1..6\<close>

         {rew_ord'="tless_true", rls'= Rule_Set.empty, calc = [], srls = Rule_Set.empty, prls = Rule_Set.empty, crls = Rule_Set.empty,

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

         @{thm inverse_ztransform.simps})]

 \<close>

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

   where

 "inverse_ztransform2 X_eq X_z = (

   let

     X = Take X_eq;

     X' = Rewrite ''ruleZY''  X;

     X_z = lhs X';

     zzz = argument_in X_z;

     funterm = rhs X';

     pbz = SubProblem (''Isac_Knowledge'',

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

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

       [REAL funterm, REAL zzz];

     pbz_eq = Take (X_z = pbz);

     pbz_eq = Rewrite ''ruleYZ''  pbz_eq;

     X_zeq = Take (X_z = rhs pbz_eq);

     n_eq = (Rewrite_Set ''inverse_z'' ) X_zeq

   in n_eq)"

 setup \<open>KEStore_Elems.add_mets

     [MethodC.prep_input @{theory} "met_SP_Ztrans_inv_sub" [] MethodC.id_empty

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

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

           ("#Find"  ,["stepResponse n_eq"])], \<comment> \<open>TODO: unused, "u [n]" is introduced by rule1..6\<close>

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

           srls = Rule_Def.Repeat {id="srls_partial_fraction", 

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

               erls = Rule_Set.append_rules "erls_in_srls_partial_fraction" Rule_Set.empty

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

                     \<^rule_eval>\<open>less\<close> (Prog_Expr.eval_equ "#less_"),

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

                     \<^rule_eval>\<open>plus\<close> (**)(eval_binop "#add_")], 

               srls = Rule_Set.Empty, calc = [], errpatts = [],

               rules = [\<^rule_thm>\<open>NTH_CONS\<close>,

                   \<^rule_eval>\<open>plus\<close> (**)(eval_binop "#add_"),

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

                   \<^rule_eval>\<open>Prog_Expr.lhs\<close> (Prog_Expr.eval_lhs "eval_lhs_"),

                   \<^rule_eval>\<open>Prog_Expr.rhs\<close> (Prog_Expr.eval_rhs"eval_rhs_"),

                   \<^rule_eval>\<open>Prog_Expr.argument_in\<close> (Prog_Expr.eval_argument_in "Prog_Expr.argument_in"),

                   \<^rule_eval>\<open>get_denominator\<close> (eval_get_denominator "#get_denominator"),

                   \<^rule_eval>\<open>get_numerator\<close> (eval_get_numerator "#get_numerator"),

                   \<^rule_eval>\<open>factors_from_solution\<close> (eval_factors_from_solution "#factors_from_solution")

                   ], scr = Rule.Empty_Prog},

           prls = Rule_Set.empty, crls = Rule_Set.empty, errpats = [], nrls = norm_Rational},

         @{thm inverse_ztransform2.simps})]

 \<close>

 ML \<open>

 \<close> ML \<open>

 \<close> ML \<open>

 \<close>

 end