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

           (Print_Mode.setmp [] (Syntax.string_of_term (thy2ctxt 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 ""

              (Print_Mode.setmp [] (Syntax.string_of_term (thy2ctxt 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

  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)"

ML {*

val ansatz_rls = prep_rls(

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

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

	  rules = 

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

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

	   ], 

	 scr = EmptyScr}:rls);

*}

ML {*

val equival_trans = prep_rls(

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

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

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

*}

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

ML {*

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

  [("ansatz_rls", ansatz_rls),

   ("equival_trans", equival_trans)

   ]);

*}

subsection {* Specification *}

consts

  decomposedFunction :: "real => una"

ML {*

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 = 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 = [],

    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 = ProofContext.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, prls = e_rls,

    crls = e_rls, nrls = e_rls}, 

     "Script PartFracScript (f_f::real) (zzz::real) =                    " ^(*f_f: 3 / (z * (z - 1 / 4 + -1 / 8 * (1 / z)), zzz: z*)

     " (let f_f = Take f_f;                                       " ^

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

     "   f_f = (Rewrite_Set norm_Rational False) f_f;             " ^(*f_f: 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',                 " ^

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

     "     [no_met]) [BOOL equ, REAL zzz]);                       " ^(*L_L: [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);                    " ^(*eql: 3 / ((z - 1 / 2) * (z - -1 / 4)) *) 

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

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

     "   eq = (Try (Rewrite_Set equival_trans False)) eq;         " ^(*eq: 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;                                  " ^(*eq_a: 3 = A * (z - -1 / 4) + B * (z - 1 / 2)*)

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

     "   eq_a = (Rewrite_Set norm_Rational False) eq_a;           " ^(*eq_a: 3 = 3 * A / 4*)

     "   (sol_a::bool list) =                                     " ^

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

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

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

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

     "   eq_b = (Substitute [zzz = z2]) eq_b;                     " ^(*eq_b: *)

     "   eq_b = (Rewrite_Set norm_Rational False) eq_b;           " ^(*eq_b: *)

     "   (sol_b::bool list) =                                     " ^

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

     "     [BOOL eq_b, REAL (B::real)]);                          " ^(*sol_b: [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;                                  " ^(*pbz: A / (z - 1 / 2) + B / (z - -1 / 4)*)

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

     " in pbz)"

));

*}

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