(* Partial_Fractions 

    author: Jan Rocnik, isac team

    Copyright (c) isac team 2011

    Use is subject to license terms.

 1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890

         10        20        30        40        50        60        70        80         90      100

 *)

 header {* Partial Fraction Decomposition *}

 theory Partial_Fractions imports RootRatEq begin

 ML{*

 (*

 signature PARTFRAC =

 sig

   val ansatz_rls : rls

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

 end

 *)

 *}

 subsection {* eval_ functions *}

 consts

   factors_from_solution :: "bool list => real"

   drop_questionmarks    :: "'a => 'a"

 text {* these might be used for variants of fac_from_sol *}

 ML {*

 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;

 *}

 text {* from solutions (e.g. [z = 1, z = -2]) make linear factors (e.g. (z - 1)*(z - -2)) *}

 ML {*

 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 = e_term then error "mk_prod called with []" else prod

   | mk_prod prod (t :: []) =

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

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

         if prod = 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 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 (mk_thmid thmid "" (term_to_string''' thy prod) "",

               Trueprop $ (mk_equality (t, prod)))

          end)

        handle _ => NONE)

  | eval_factors_from_solution _ _ _ _ = NONE;

 *}

 text {* 'ansatz' introduces '?Vars' (questionable design); drop these again *}

 ML {*

 (*("drop_questionmarks", ("Partial_Fractions.drop_questionmarks", eval_drop_questionmarks ""))*)

 fun eval_drop_questionmarks (thmid:string) _

      (t as Const ("Partial_Fractions.drop_questionmarks", _) $ tm) thy =

         if contains_Var tm

         then

           let

             val tm' = var2free tm

             in SOME (mk_thmid thmid "" (term_to_string''' thy tm') "",

                  Trueprop $ (mk_equality (t, tm')))

             end

         else NONE

   | eval_drop_questionmarks _ _ _ _ = NONE;

 *}

 text {* store eval_ functions for calls from Scripts *}

 ML {*

 calclist':= overwritel (!calclist',

   [("drop_questionmarks", ("Partial_Fractions.drop'_questionmarks", eval_drop_questionmarks ""))

   ]);

 *}

 subsection {* 'ansatz' for partial fractions *}

 axiomatization where

   ansatz_2nd_order: "n / (a*b) = A/a + B/b" and

   ansatz_3rd_order: "n / (a*b*c) = A/a + B/b + C/c" and

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

   (*version 1*)

   equival_trans_2nd_order: "(n/(a*b) = A/a + B/b) = (n = A*b + B*a)" and

   equival_trans_3rd_order: "(n/(a*b*c) = A/a + B/b + C/c) = (n = A*b*c + B*a*c + C*a*b)" and

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

     (n = A*b*c*d + B*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 = A/a + B/b) = (a*b*n/x = A*b + B*a)" and

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

   multiply_4th_order: 

     "(n/x = A/a + B/b + C/c + D/d) = (a*b*c*d*n/x = A*b*c*d + B*a*c*d + C*a*b*d + D*a*b*c)"

 text {* Probably the optimal formalization woudl be ...

   multiply_2nd_order: "x = a*b ==> (n/x = A/a + B/b) = (a*b*n/x = A*b + B*a)" and

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

     (n/x = A/a + B/b + C/c) = (a*b*c*n/x = A*b*c + B*a*c + C*a*b)" and

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

     (n/x = A/a + B/b + C/c + D/d) = (a*b*c*d*n/x = A*b*c*d + B*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 = A * (z - -1 / 4) + B * (z - 1 / 2)

 ... (1==>2) ansatz

     (2==>3) multiply_*

     (3==>4) norm_Rational

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

 *}

 ML {*

 val ansatz_rls = prep_rls(

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

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

 	  rules = 

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

 	    Thm ("ansatz_3rd_order",num_str @{thm ansatz_3rd_order})

 	   ], 

 	 scr = EmptyScr}:rls);

 val equival_trans = prep_rls(

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

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

 	  rules = 

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

 	    Thm ("equival_trans_3rd_order",num_str @{thm equival_trans_3rd_order})

 	   ], 

 	 scr = EmptyScr}:rls);

 val multiply_ansatz = prep_rls(

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

 	  erls = Erls,

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

 	  rules = 

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

 	   ], 

 	 scr = EmptyScr}:rls);

 *}

 text {*store the rule set for math engine*}

 ML {*

 ruleset' := overwritelthy @{theory} (!ruleset',

   [("ansatz_rls", ansatz_rls),

    ("multiply_ansatz", multiply_ansatz),

    ("equival_trans", equival_trans)

    ]);

 *}

 subsection {* Specification *}

 consts

   decomposedFunction :: "real => una"

 ML {*

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

 store_pbt

  (prep_pbt @{theory} "pbl_simp_rat_partfrac" [] 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'''"])

   ],

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

   NONE, 

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

 *}

 subsection {* Method *}

 consts

   PartFracScript  :: "[real,real,  real] => real" 

     ("((Script PartFracScript (_ _ =))// (_))" 9)

 text {* rule set for functions called in the Script *}

 ML {*

   val srls_partial_fraction = Rls {id="srls_partial_fraction", 

     preconds = [],

     rew_ord = ("termlessI",termlessI),

     erls = append_rls "erls_in_srls_partial_fraction" e_rls

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

        Calc ("Orderings.ord_class.less",eval_equ "#less_"),

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

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

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

     rules = [

        Thm ("NTH_CONS",num_str @{thm NTH_CONS}),

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

        Thm ("NTH_NIL",num_str @{thm NTH_NIL}),

        Calc("Tools.lhs", eval_lhs "eval_lhs_"),

        Calc("Tools.rhs", eval_rhs"eval_rhs_"),

        Calc("Atools.argument'_in", eval_argument_in "Atools.argument'_in"),

        Calc("Rational.get_denominator", eval_get_denominator "#get_denominator"),

        Calc("Rational.get_numerator", eval_get_numerator "#get_numerator"),

        Calc("Partial_Fractions.factors_from_solution",

          eval_factors_from_solution "#factors_from_solution"),

        Calc("Partial_Fractions.drop_questionmarks", eval_drop_questionmarks "#drop_?")],

     scr = EmptyScr};

 *}

 ML {*

 eval_drop_questionmarks;

 *}

 ML {*

 val ctxt = Proof_Context.init_global @{theory};

 val SOME t = parseNEW ctxt "eqr = drop_questionmarks eqr";

 *}

 ML {*

 parseNEW ctxt "decomposedFunction p_p'''";

 parseNEW ctxt "decomposedFunction";

 *}

 ML {*

 *}

 ML {* (* current version, error outcommented *)

 store_met

  (prep_met @{theory} "met_partial_fraction" [] 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'''"])],

    {rew_ord'="tless_true", rls'= e_rls, calc = [], srls = srls_partial_fraction, prls = e_rls,

     crls = e_rls, errpats = [], nrls = e_rls},                         (*f_f = 3 / (z * (z - 1 / 4 + -1 / 8 * (1 / z)), zzz: z*)

    "Script PartFracScript (f_f::real) (zzz::real) =   " ^(*([], Frm), Problem (Partial_Fractions, [partial_fraction, rational, simplification])*)

    "(let f_f = Take f_f;                              " ^(*([1], Frm), 3 / (z * (z - 1 / 4 + -1 / 8 * (1 / z)))*)

    "  (num_orig::real) = get_numerator f_f;           " ^(*           num_orig = 3*)

    "  f_f = (Rewrite_Set norm_Rational False) f_f;    " ^(*([1], Res), 24 / (-1 + -2 * z + 8 * z ^^^ 2)*)

    "  (denom::real) = get_denominator f_f;            " ^(*           denom = -1 + -2 * z + 8 * z ^^^ 2*)

    "  (equ::bool) = (denom = (0::real));              " ^(*           equ = -1 + -2 * z + 8 * z ^^^ 2 = 0*)

    "  (L_L::bool list) = (SubProblem (PolyEq',        " ^(*([2], Pbl), solve (-1 + -2 * z + 8 * z ^^^ 2 = 0, z)*)

    "    [abcFormula, degree_2, polynomial, univariate, equation], " ^

    "    [no_met]) [BOOL equ, REAL zzz]);              " ^(*([2], Res), [z = 1 / 2, z = -1 / 4]*)

    "  (facs::real) = factors_from_solution L_L;       " ^(*           facs: (z - 1 / 2) * (z - -1 / 4)*)

    "  (eql::real) = Take (num_orig / facs);           " ^(*([3], Frm), 33 / ((z - 1 / 2) * (z - -1 / 4)) *) 

    "  (eqr::real) = (Try (Rewrite_Set ansatz_rls False)) eql;  " ^(*([3], Res), ?A / (z - 1 / 2) + ?B / (z - -1 / 4)*)

    "  (eq::bool) = Take (eql = eqr);                  " ^(*([4], Frm), 3 / ((z - 1 / 2) * (z - -1 / 4)) = ?A / (z - 1 / 2) + ?B / (z - -1 / 4)*)

    "  eq = (Try (Rewrite_Set equival_trans False)) eq;" ^(*([4], Res), 3 = ?A * (z - -1 / 4) + ?B * (z - 1 / 2)*) 

    "  eq = drop_questionmarks eq;                     " ^(*           eq = 3 = A * (z - -1 / 4) + B * (z - 1 / 2)*)

    "  (z1::real) = (rhs (NTH 1 L_L));                 " ^(*           z1 = 1 / 2*)

    "  (z2::real) = (rhs (NTH 2 L_L));                 " ^(*           z2 = -1 / 4*)

    "  (eq_a::bool) = Take eq;                         " ^(*([5], Frm), 3 = A * (z - -1 / 4) + B * (z - 1 / 2)*)

    "  eq_a = (Substitute [zzz = z1]) eq;              " ^(*([5], Res), 3 = A * (1 / 2 - -1 / 4) + B * (1 / 2 - 1 / 2)*)

    "  eq_a = (Rewrite_Set norm_Rational False) eq_a;  " ^(*([6], Res), 3 = 3 * A / 4*)

    "  (sol_a::bool list) =                            " ^(*([7], Pbl), solve (3 = 3 * A / 4, A)*)

    "    (SubProblem (Isac', [univariate,equation], [no_met])   " ^

    "    [BOOL eq_a, REAL (A::real)]);                 " ^(*([7], Res), [A = 4]*)

    "  (a::real) = (rhs (NTH 1 sol_a));                " ^(*           a = 4*)

    "  (eq_b::bool) = Take eq;                         " ^(*([8], Frm), 3 = A * (z - -1 / 4) + B * (z - 1 / 2)*)

    "  eq_b = (Substitute [zzz = z2]) eq_b;            " ^(*([8], Res), 3 = A * (-1 / 4 - -1 / 4) + B * (-1 / 4 - 1 / 2)*)

    "  eq_b = (Rewrite_Set norm_Rational False) eq_b;  " ^(*([9], Res), 3 = -3 * B / 4*)

    "  (sol_b::bool list) =                            " ^(*([10], Pbl), solve (3 = -3 * B / 4, B)*)

    "    (SubProblem (Isac', [univariate,equation], [no_met])   " ^

    "    [BOOL eq_b, REAL (B::real)]);                 " ^(*([10], Res), [B = -4]*)

    "  (b::real) = (rhs (NTH 1 sol_b));                " ^(*           b = -4*)

    "  eqr = drop_questionmarks eqr;                   " ^(*           eqr = A / (z - 1 / 2) + B / (z - -1 / 4)*)

    "  (pbz::real) = Take eqr;                         " ^(*([11], Frm), A / (z - 1 / 2) + B / (z - -1 / 4)*)

    "  pbz = ((Substitute [A = a, B = b]) pbz)         " ^(*([11], Res), 4 / (z - 1 / 2) + -4 / (z - -1 / 4)*)

    "in pbz)"                                             (*([], Res), 4 / (z - 1 / 2) + -4 / (z - -1 / 4)*)

 ));

 *}

 ML {*

 (*

   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'))];

 *)

 *}

 subsection {**}

 end