(* Partial_Fractions 

   author: Jan Rocnik, isac team

   Copyright (c) isac team 2011

   Use is subject to license terms.

*)

(* Partial Fraction Decomposition *)

theory Partial_Fractions imports RootRatEq begin

ML\<open>

(*

signature PARTFRAC =

sig

  val ansatz_rls : rls

  val ansatz_rls_ : theory -> term -> (term * term list) option

end

*)

\<close>

subsection \<open>eval_ functions\<close>

consts

  factors_from_solution :: "bool list => real"

  AA                    :: real

  BB                    :: real

text \<open>these might be used for variants of fac_from_sol\<close>

ML \<open>

fun mk_minus_1 T = Free("-1", T); (*TODO DELETE WITH numbers_to_string*)

fun flip_sign t = (*TODO improve for use in factors_from_solution: -(-1) etc*)

  let val minus_1 = t |> type_of |> mk_minus_1

  in HOLogic.mk_binop "Groups.times_class.times" (minus_1, t) end;

\<close>

text \<open>from solutions (e.g. [z = 1, z = -2]) make linear factors (e.g. (z - 1)*(z - -2))\<close>

ML \<open>

fun fac_from_sol s =

  let val (lhs, rhs) = HOLogic.dest_eq s

  in HOLogic.mk_binop "Groups.minus_class.minus" (lhs, rhs) end;

fun mk_prod prod [] =

      if prod = Rule.e_term then error "mk_prod called with []" else prod

  | mk_prod prod (t :: []) =

      if prod = Rule.e_term then t else HOLogic.mk_binop "Groups.times_class.times" (prod, t)

  | mk_prod prod (t1 :: t2 :: ts) =

        if prod = Rule.e_term 

        then 

           let val p = HOLogic.mk_binop "Groups.times_class.times" (t1, t2)

           in mk_prod p ts end 

        else 

           let val p = HOLogic.mk_binop "Groups.times_class.times" (prod, t1)

           in mk_prod p (t2 :: ts) end 

fun factors_from_solution sol = 

  let val ts = HOLogic.dest_list sol

  in mk_prod Rule.e_term (map fac_from_sol ts) end;

(*("factors_from_solution", ("Partial_Fractions.factors_from_solution", 

     eval_factors_from_solution ""))*)

fun eval_factors_from_solution (thmid:string) _

     (t as Const ("Partial_Fractions.factors_from_solution", _) $ sol) thy =

       ((let val prod = factors_from_solution sol

         in SOME (TermC.mk_thmid thmid (Rule.term_to_string''' thy prod) "",

              HOLogic.Trueprop $ (TermC.mk_equality (t, prod)))

         end)

       handle _ => NONE)

 | eval_factors_from_solution _ _ _ _ = NONE;

\<close>

subsection \<open>'ansatz' for partial fractions\<close>

axiomatization where

  ansatz_2nd_order: "n / (a*b) = AA/a + BB/b" and

  ansatz_3rd_order: "n / (a*b*c) = AA/a + BB/b + C/c" and

  ansatz_4th_order: "n / (a*b*c*d) = AA/a + BB/b + C/c + D/d" and

  (*version 1*)

  equival_trans_2nd_order: "(n/(a*b) = AA/a + BB/b) = (n = AA*b + BB*a)" and

  equival_trans_3rd_order: "(n/(a*b*c) = AA/a + BB/b + C/c) = (n = AA*b*c + BB*a*c + C*a*b)" and

  equival_trans_4th_order: "(n/(a*b*c*d) = AA/a + BB/b + C/c + D/d) = 

    (n = AA*b*c*d + BB*a*c*d + C*a*b*d + D*a*b*c)" and

  (*version 2: not yet used, see partial_fractions.sml*)

  multiply_2nd_order: "(n/x = AA/a + BB/b) = (a*b*n/x = AA*b + BB*a)" and

  multiply_3rd_order: "(n/x = AA/a + BB/b + C/c) = (a*b*c*n/x = AA*b*c + BB*a*c + C*a*b)" and

  multiply_4th_order: 

    "(n/x = AA/a + BB/b + C/c + D/d) = (a*b*c*d*n/x = AA*b*c*d + BB*a*c*d + C*a*b*d + D*a*b*c)"

text \<open>Probably the optimal formalization woudl be ...

  multiply_2nd_order: "x = a*b ==> (n/x = AA/a + BB/b) = (a*b*n/x = AA*b + BB*a)" and

  multiply_3rd_order: "x = a*b*c ==>

    (n/x = AA/a + BB/b + C/c) = (a*b*c*n/x = AA*b*c + BB*a*c + C*a*b)" and

  multiply_4th_order: "x = a*b*c*d ==>

    (n/x = AA/a + BB/b + C/c + D/d) = (a*b*c*d*n/x = AA*b*c*d + BB*a*c*d + C*a*b*d + D*a*b*c)"

... because it would allow to start the ansatz as follows

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

(2) 3 / (z * (z - 1 / 4 + -1 / 8 * (1 / z))) = AA / (z - 1 / 2) + BB / (z - -1 / 4)

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

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

(4) 3 = AA * (z - -1 / 4) + BB * (z - 1 / 2)

... (1==>2) ansatz

    (2==>3) multiply_*

    (3==>4) norm_Rational

TODOs for this version are in partial_fractions.sml "--- progr.vers.2: "

\<close>

ML \<open>

val ansatz_rls = prep_rls'(

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

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

	  rules = 

	   [Rule.Thm ("ansatz_2nd_order",TermC.num_str @{thm ansatz_2nd_order}),

	    Rule.Thm ("ansatz_3rd_order",TermC.num_str @{thm ansatz_3rd_order})

	   ], 

	 scr = Rule.EmptyScr});

val equival_trans = prep_rls'(

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

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

	  rules = 

	   [Rule.Thm ("equival_trans_2nd_order",TermC.num_str @{thm equival_trans_2nd_order}),

	    Rule.Thm ("equival_trans_3rd_order",TermC.num_str @{thm equival_trans_3rd_order})

	   ], 

	 scr = Rule.EmptyScr});

val multiply_ansatz = prep_rls'(

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

	  erls = Rule.Erls,

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

	  rules = 

	   [Rule.Thm ("multiply_2nd_order",TermC.num_str @{thm multiply_2nd_order})

	   ], 

	 scr = Rule.EmptyScr});

\<close>

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

setup \<open>KEStore_Elems.add_rlss 

  [("ansatz_rls", (Context.theory_name @{theory}, ansatz_rls)), 

  ("multiply_ansatz", (Context.theory_name @{theory}, multiply_ansatz)), 

  ("equival_trans", (Context.theory_name @{theory}, equival_trans))]\<close>

subsection \<open>Specification\<close>

consts

  decomposedFunction :: "real => una"

ML \<open>

Celem.check_guhs_unique := false; (*WN120307 REMOVE after editing*)

\<close>

setup \<open>KEStore_Elems.add_pbts

  [(Specify.prep_pbt @{theory} "pbl_simp_rat_partfrac" [] Celem.e_pblID

      (["partial_fraction", "rational", "simplification"],

        [("#Given" ,["functionTerm t_t", "solveFor v_v"]),

          (* TODO: call this sub-problem with appropriate functionTerm: 

            leading coefficient of the denominator is 1: to be checked here! and..

            ("#Where" ,["((get_numerator t_t) has_degree_in v_v) < 

               ((get_denominator t_t) has_degree_in v_v)"]), TODO*)

          ("#Find"  ,["decomposedFunction p_p'''"])],

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

        NONE, 

        [["simplification","of_rationals","to_partial_fraction"]]))]\<close>

subsection \<open>Method\<close>

text \<open>rule set for functions called in the Program\<close>

ML \<open>

  val srls_partial_fraction = 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", Prog_Expr.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",TermC.num_str @{thm NTH_CONS}),

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

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

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

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

       Rule.Calc("Prog_Expr.argument'_in", Prog_Expr.eval_argument_in "Prog_Expr.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")

       ],

    scr = Rule.EmptyScr};

\<close>

(* current version, error outcommented *)

partial_function (tailrec) partial_fraction :: "real \<Rightarrow> real \<Rightarrow> real"

  where

"partial_fraction f_f zzz =              \<comment> \<open>([1], Frm), 3 / (z * (z - 1 / 4 + -1 / 8 * (1 / z)))\<close>

(let f_f = Take f_f;                                                             \<comment> \<open>num_orig = 3\<close>

  num_orig = get_numerator f_f;                  \<comment> \<open>([1], Res), 24 / (-1 + -2 * z + 8 * z ^^^ 2)\<close>

  f_f = (Rewrite_Set ''norm_Rational'') f_f;                \<comment> \<open>denom = -1 + -2 * z + 8 * z ^^^ 2\<close>

  denom = get_denominator f_f;                            \<comment> \<open>equ = -1 + -2 * z + 8 * z ^^^ 2 = 0\<close>

  equ = denom = (0::real);

  \<comment> \<open>-----                                  ([2], Pbl), solve (-1 + -2 * z + 8 * z ^^^ 2 = 0, z)\<close>

  L_L = SubProblem (''Partial_Fractions'',                 \<comment> \<open>([2], Res), [z = 1 / 2, z = -1 / 4\<close>

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

    [''no_met'']) [BOOL equ, REAL zzz];                      \<comment> \<open>facs: (z - 1 / 2) * (z - -1 / 4)\<close>

  facs = factors_from_solution L_L;             \<comment> \<open>([3], Frm), 33 / ((z - 1 / 2) * (z - -1 / 4))\<close>

  eql = Take (num_orig / facs);              \<comment> \<open>([3], Res), ?A / (z - 1 / 2) + ?B / (z - -1 / 4)\<close>

  eqr = (Try (Rewrite_Set ''ansatz_rls'')) eql;

          \<comment> \<open>([4], Frm), 3 / ((z - 1 / 2) * (z - -1 / 4)) = ?A / (z - 1 / 2) + ?B / (z - -1 / 4)\<close>

  eq = Take (eql = eqr);                 \<comment> \<open>([4], Res), 3 = ?A * (z - -1 / 4) + ?B * (z - 1 / 2)\<close>

  eq = (Try (Rewrite_Set ''equival_trans'')) eq; 

                                                \<comment> \<open>eq = 3 = AA * (z - -1 / 4) + BB * (z - 1 / 2)\<close>

  z1 = rhs (NTH 1 L_L);                                                           \<comment> \<open>z2 = -1 / 4\<close>

  z2 = rhs (NTH 2 L_L);                  \<comment> \<open>([5], Frm), 3 = AA * (z - -1 / 4) + BB * (z - 1 / 2)\<close>

  eq_a = Take eq;                \<comment> \<open>([5], Res), 3 = AA * (1 / 2 - -1 / 4) + BB * (1 / 2 - 1 / 2)\<close>

  eq_a = Substitute [zzz = z1] eq;                                 \<comment> \<open>([6], Res), 3 = 3 * AA / 4\<close>

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

\<comment> \<open>-----                                                  ([7], Pbl), solve (3 = 3 * AA / 4, AA)\<close>

                                                                         \<comment> \<open>([7], Res), [AA = 4]\<close>

  sol_a = SubProblem (''Isac_Knowledge'', [''univariate'',''equation''], [''no_met''])

      [BOOL eq_a, REAL (AA::real)] ;                                                    \<comment> \<open>a = 4\<close>

  a = rhs (NTH 1 sol_a);                 \<comment> \<open>([8], Frm), 3 = AA * (z - -1 / 4) + BB * (z - 1 / 2)\<close>

  eq_b = Take eq;              \<comment> \<open>([8], Res), 3 = AA * (-1 / 4 - -1 / 4) + BB * (-1 / 4 - 1 / 2)\<close>

  eq_b = Substitute [zzz = z2] eq_b;                              \<comment> \<open>([9], Res), 3 = -3 * BB / 4\<close>

  eq_b = (Rewrite_Set ''norm_Rational'') eq_b;       \<comment> \<open>([10], Pbl), solve (3 = -3 * BB / 4, BB)\<close>

  sol_b = SubProblem (''Isac_Knowledge'',                              \<comment> \<open>([10], Res), [BB = -4]\<close>

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

    [BOOL eq_b, REAL (BB::real)];                                                      \<comment> \<open>b = -4\<close>

  b = rhs (NTH 1 sol_b);                           \<comment> \<open>eqr = AA / (z - 1 / 2) + BB / (z - -1 / 4)\<close>

  pbz = Take eqr;                            \<comment> \<open>([11], Res), 4 / (z - 1 / 2) + -4 / (z - -1 / 4)\<close>

  pbz = Substitute [AA = a, BB = b] pbz        \<comment> \<open>([], Res), 4 / (z - 1 / 2) + -4 / (z - -1 / 4)\<close>

in pbz)                                                                                "

setup \<open>KEStore_Elems.add_mets

    [Specify.prep_met @{theory} "met_partial_fraction" [] Celem.e_metID

      (["simplification","of_rationals","to_partial_fraction"], 

        [("#Given" ,["functionTerm t_t", "solveFor v_v"]),

          (*("#Where" ,["((get_numerator t_t) has_degree_in v_v) < 

            ((get_denominator t_t) has_degree_in v_v)"]), TODO*)

          ("#Find"  ,["decomposedFunction p_p'''"])],

        (*f_f = 3 / (z * (z - 1 / 4 + -1 / 8 * (1 / z)), zzz: z*)

        {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},

        (*([], Frm), Problem (Partial_Fractions, [partial_fraction, rational, simplification])*)

        @{thm partial_fraction.simps})]

\<close>

ML \<open>

(*

  val fmz =                                             

    ["functionTerm (3 / (z * (z - 1 / 4 + -1 / 8 * (1 / z))))", 

      "solveFor z", "functionTerm p_p"];

  val (dI',pI',mI') =

    ("Partial_Fractions", 

      ["partial_fraction", "rational", "simplification"],

      ["simplification","of_rationals","to_partial_fraction"]);

  val (p,_,f,nxt,_,pt) = CalcTreeTEST [(fmz, (dI',pI',mI'))];

*)

\<close>

end