(* Title:  Inverse_Z_Transform

    Author: Jan Rocnik

    (c) copyright due to lincense terms.

 *)

 theory Inverse_Z_Transform imports PolyEq Diff_App 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.function_empty), 

 	  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>

 problem pbl_SP : "SignalProcessing" = \<open>Rule_Set.empty\<close>

 problem pbl_SP_Ztrans : "Z_Transform/SignalProcessing" = \<open>Rule_Set.empty\<close>

 problem pbl_SP_Ztrans_inv : "Inverse/Z_Transform/SignalProcessing" =

   \<open>Rule_Set.append_rules "empty" Rule_Set.empty [(*for preds in where_*)]\<close>

   Method_Ref: "SignalProcessing/Z_Transform/Inverse"

   Given: "filterExpression X_eq"

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

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

 method met_SP : "SignalProcessing" =

   \<open>{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}\<close>

 method met_SP_Ztrans : "SignalProcessing/Z_Transform" =

   \<open>{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}\<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) "

 method met_SP_Ztrans_inv : "SignalProcessing/Z_Transform/Inverse" =

   \<open>{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}\<close>

   Program: inverse_ztransform.simps

   Given: "filterExpression X_eq" "functionName X_z"

   Find: "stepResponse n_eq" \<comment> \<open>TODO: unused, "u [n]" is introduced by rule1..6\<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)"

 method met_SP_Ztrans_inv_sub : "SignalProcessing/Z_Transform/Inverse_sub" =

   \<open>{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 [

         \<^rule_eval>\<open>less\<close> (Prog_Expr.eval_equ "#less_"), (* ...for asm in NTH_CONS*)

         (*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}\<close>

   Program: inverse_ztransform2.simps

   Given: "filterExpression X_eq" "functionName X_z"

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

 ML \<open>

 \<close> ML \<open>

 \<close> ML \<open>

 \<close>

 end