(* 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 ("rule4", @{thm rule4})

	   ], 

	 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 ("Orderings.ord_class.less", Prog_Expr.eval_equ "#less_"),

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

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

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

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

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

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

                  Rule.Eval ("Prog_Expr.lhs", Prog_Expr.eval_lhs "eval_lhs_"),

                  Rule.Eval ("Prog_Expr.rhs", Prog_Expr.eval_rhs"eval_rhs_"),

                  Rule.Eval ("Prog_Expr.argument_in", Prog_Expr.eval_argument_in "Prog_Expr.argument_in"),

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

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

                  Rule.Eval ("Partial_Fractions.factors_from_solution",

                    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