(* 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