src/Tools/isac/Knowledge/Partial_Fractions.thy
author Mathias Lehnfeld <s1210629013@students.fh-hagenberg.at>
Sun, 02 Feb 2014 03:09:40 +0100
changeset 55380 7be2ad0e4acb
parent 55373 4f3f530f3cf6
child 55444 ede4248a827b
permissions -rwxr-xr-x
ad 967c8a1eb6b1 (7): remove all code concerned with 'mets = Unsynchronized.ref'
neuper@42376
     1
(* Partial_Fractions 
jan@42344
     2
   author: Jan Rocnik, isac team
jan@42344
     3
   Copyright (c) isac team 2011
jan@42344
     4
   Use is subject to license terms.
jan@42344
     5
jan@42344
     6
1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890
jan@42344
     7
        10        20        30        40        50        60        70        80         90      100
jan@42344
     8
*)
neuper@42376
     9
header {* Partial Fraction Decomposition *}
jan@42344
    10
neuper@42289
    11
neuper@42376
    12
theory Partial_Fractions imports RootRatEq begin
jan@42353
    13
jan@42353
    14
ML{*
neuper@42376
    15
(*
jan@42353
    16
signature PARTFRAC =
jan@42353
    17
sig
jan@42353
    18
  val ansatz_rls : rls
jan@42353
    19
  val ansatz_rls_ : theory -> term -> (term * term list) option
jan@42353
    20
end
neuper@42376
    21
*)
jan@42353
    22
*}
jan@42353
    23
neuper@42376
    24
subsection {* eval_ functions *}
jan@42344
    25
consts
neuper@42359
    26
  factors_from_solution :: "bool list => real"
neuper@42359
    27
  drop_questionmarks    :: "'a => 'a"
jan@42344
    28
neuper@42376
    29
text {* these might be used for variants of fac_from_sol *}
neuper@42289
    30
ML {*
jan@42344
    31
fun mk_minus_1 T = Free("-1", T); (*TODO DELETE WITH numbers_to_string*)
jan@42344
    32
fun flip_sign t = (*TODO improve for use in factors_from_solution: -(-1) etc*)
jan@42344
    33
  let val minus_1 = t |> type_of |> mk_minus_1
jan@42344
    34
  in HOLogic.mk_binop "Groups.times_class.times" (minus_1, t) end;
neuper@42376
    35
*}
neuper@42376
    36
neuper@42376
    37
text {* from solutions (e.g. [z = 1, z = -2]) make linear factors (e.g. (z - 1)*(z - -2)) *}
neuper@42376
    38
ML {*
jan@42344
    39
fun fac_from_sol s =
jan@42344
    40
  let val (lhs, rhs) = HOLogic.dest_eq s
jan@42367
    41
  in HOLogic.mk_binop "Groups.minus_class.minus" (lhs, rhs) end;
jan@42344
    42
jan@42344
    43
fun mk_prod prod [] =
jan@42344
    44
      if prod = e_term then error "mk_prod called with []" else prod
jan@42344
    45
  | mk_prod prod (t :: []) =
jan@42344
    46
      if prod = e_term then t else HOLogic.mk_binop "Groups.times_class.times" (prod, t)
jan@42344
    47
  | mk_prod prod (t1 :: t2 :: ts) =
jan@42344
    48
        if prod = e_term 
jan@42344
    49
        then 
jan@42344
    50
           let val p = HOLogic.mk_binop "Groups.times_class.times" (t1, t2)
jan@42344
    51
           in mk_prod p ts end 
jan@42344
    52
        else 
jan@42344
    53
           let val p = HOLogic.mk_binop "Groups.times_class.times" (prod, t1)
jan@42344
    54
           in mk_prod p (t2 :: ts) end 
jan@42344
    55
jan@42344
    56
fun factors_from_solution sol = 
jan@42344
    57
  let val ts = HOLogic.dest_list sol
jan@42344
    58
  in mk_prod e_term (map fac_from_sol ts) end;
jan@42344
    59
neuper@42376
    60
(*("factors_from_solution", ("Partial_Fractions.factors_from_solution", 
neuper@42376
    61
     eval_factors_from_solution ""))*)
jan@42352
    62
fun eval_factors_from_solution (thmid:string) _
jan@42352
    63
     (t as Const ("Partial_Fractions.factors_from_solution", _) $ sol) thy =
jan@42352
    64
       ((let val prod = factors_from_solution sol
neuper@52070
    65
         in SOME (mk_thmid thmid "" (term_to_string''' thy prod) "",
neuper@52070
    66
              Trueprop $ (mk_equality (t, prod)))
jan@42352
    67
         end)
jan@42352
    68
       handle _ => NONE)
jan@42352
    69
 | eval_factors_from_solution _ _ _ _ = NONE;
jan@42344
    70
*}
jan@42344
    71
neuper@42376
    72
text {* 'ansatz' introduces '?Vars' (questionable design); drop these again *}
neuper@42359
    73
ML {*
neuper@42359
    74
(*("drop_questionmarks", ("Partial_Fractions.drop_questionmarks", eval_drop_questionmarks ""))*)
neuper@42359
    75
fun eval_drop_questionmarks (thmid:string) _
neuper@42359
    76
     (t as Const ("Partial_Fractions.drop_questionmarks", _) $ tm) thy =
neuper@42359
    77
        if contains_Var tm
neuper@42359
    78
        then
neuper@42359
    79
          let
neuper@42359
    80
            val tm' = var2free tm
neuper@52070
    81
            in SOME (mk_thmid thmid "" (term_to_string''' thy tm') "",
neuper@52070
    82
                 Trueprop $ (mk_equality (t, tm')))
neuper@42359
    83
            end
neuper@42359
    84
        else NONE
neuper@42359
    85
  | eval_drop_questionmarks _ _ _ _ = NONE;
neuper@42376
    86
*}
neuper@42359
    87
neuper@42376
    88
text {* store eval_ functions for calls from Scripts *}
s1210629013@52145
    89
setup {* KEStore_Elems.add_calcs
s1210629013@52145
    90
  [("drop_questionmarks", ("Partial_Fractions.drop'_questionmarks", eval_drop_questionmarks ""))] *}
neuper@42359
    91
neuper@42376
    92
subsection {* 'ansatz' for partial fractions *}
jan@42353
    93
axiomatization where
jan@42358
    94
  ansatz_2nd_order: "n / (a*b) = A/a + B/b" and
neuper@42376
    95
  ansatz_3rd_order: "n / (a*b*c) = A/a + B/b + C/c" and
neuper@42376
    96
  ansatz_4th_order: "n / (a*b*c*d) = A/a + B/b + C/c + D/d" and
neuper@42386
    97
  (*version 1*)
neuper@42376
    98
  equival_trans_2nd_order: "(n/(a*b) = A/a + B/b) = (n = A*b + B*a)" and
neuper@42376
    99
  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
neuper@42376
   100
  equival_trans_4th_order: "(n/(a*b*c*d) = A/a + B/b + C/c + D/d) = 
neuper@42386
   101
    (n = A*b*c*d + B*a*c*d + C*a*b*d + D*a*b*c)" and
neuper@42386
   102
  (*version 2: not yet used, see partial_fractions.sml*)
neuper@42387
   103
  multiply_2nd_order: "(n/x = A/a + B/b) = (a*b*n/x = A*b + B*a)" and
neuper@42387
   104
  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
neuper@42387
   105
  multiply_4th_order: 
neuper@42387
   106
    "(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)"
neuper@42387
   107
neuper@42387
   108
text {* Probably the optimal formalization woudl be ...
neuper@42387
   109
neuper@42386
   110
  multiply_2nd_order: "x = a*b ==> (n/x = A/a + B/b) = (a*b*n/x = A*b + B*a)" and
neuper@42386
   111
  multiply_3rd_order: "x = a*b*c ==>
neuper@42386
   112
    (n/x = A/a + B/b + C/c) = (a*b*c*n/x = A*b*c + B*a*c + C*a*b)" and
neuper@42386
   113
  multiply_4th_order: "x = a*b*c*d ==>
neuper@42386
   114
    (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)"
jan@42353
   115
neuper@42387
   116
... because it would allow to start the ansatz as follows
neuper@42387
   117
(1) 3 / (z * (z - 1 / 4 + -1 / 8 * (1 / z))) = 3 / (z * (z - 1 / 4 + -1 / 8 * (1 / z)))
neuper@42387
   118
(2) 3 / (z * (z - 1 / 4 + -1 / 8 * (1 / z))) = AA / (z - 1 / 2) + BB / (z - -1 / 4)
neuper@42387
   119
(3) (z - 1 / 2) * (z - -1 / 4) * 3 / (z * (z - 1 / 4 + -1 / 8 * (1 / z))) = 
neuper@42387
   120
    (z - 1 / 2) * (z - -1 / 4) * AA / (z - 1 / 2) + BB / (z - -1 / 4)
neuper@42387
   121
(4) 3 = A * (z - -1 / 4) + B * (z - 1 / 2)
neuper@42387
   122
neuper@42387
   123
... (1==>2) ansatz
neuper@42387
   124
    (2==>3) multiply_*
neuper@42387
   125
    (3==>4) norm_Rational
neuper@42387
   126
TODOs for this version ar in partial_fractions.sml "--- progr.vers.2: "
neuper@42387
   127
*}
neuper@42387
   128
jan@42353
   129
ML {*
jan@42353
   130
val ansatz_rls = prep_rls(
jan@42353
   131
  Rls {id = "ansatz_rls", preconds = [], rew_ord = ("dummy_ord",dummy_ord), 
neuper@42451
   132
	  erls = Erls, srls = Erls, calc = [], errpatts = [],
jan@42353
   133
	  rules = 
neuper@42376
   134
	   [Thm ("ansatz_2nd_order",num_str @{thm ansatz_2nd_order}),
neuper@42376
   135
	    Thm ("ansatz_3rd_order",num_str @{thm ansatz_3rd_order})
jan@42353
   136
	   ], 
jan@42353
   137
	 scr = EmptyScr}:rls);
jan@42353
   138
jan@42354
   139
val equival_trans = prep_rls(
jan@42354
   140
  Rls {id = "equival_trans", preconds = [], rew_ord = ("dummy_ord",dummy_ord), 
neuper@42451
   141
	  erls = Erls, srls = Erls, calc = [], errpatts = [],
jan@42354
   142
	  rules = 
neuper@42376
   143
	   [Thm ("equival_trans_2nd_order",num_str @{thm equival_trans_2nd_order}),
neuper@42376
   144
	    Thm ("equival_trans_3rd_order",num_str @{thm equival_trans_3rd_order})
jan@42354
   145
	   ], 
jan@42354
   146
	 scr = EmptyScr}:rls);
neuper@42386
   147
neuper@42386
   148
val multiply_ansatz = prep_rls(
neuper@42386
   149
  Rls {id = "multiply_ansatz", preconds = [], rew_ord = ("dummy_ord",dummy_ord), 
neuper@42386
   150
	  erls = Erls,
neuper@42451
   151
	  srls = Erls, calc = [], errpatts = [],
neuper@42386
   152
	  rules = 
neuper@42386
   153
	   [Thm ("multiply_2nd_order",num_str @{thm multiply_2nd_order})
neuper@42386
   154
	   ], 
neuper@42386
   155
	 scr = EmptyScr}:rls);
jan@42354
   156
*}
jan@42354
   157
jan@42354
   158
text {*store the rule set for math engine*}
neuper@52125
   159
setup {* KEStore_Elems.add_rlss 
neuper@52125
   160
  [("ansatz_rls", (Context.theory_name @{theory}, ansatz_rls)), 
neuper@52125
   161
  ("multiply_ansatz", (Context.theory_name @{theory}, multiply_ansatz)), 
neuper@52125
   162
  ("equival_trans", (Context.theory_name @{theory}, equival_trans))] *}
jan@42344
   163
neuper@42376
   164
subsection {* Specification *}
jan@42344
   165
neuper@42376
   166
consts
neuper@42376
   167
  decomposedFunction :: "real => una"
neuper@42376
   168
neuper@42289
   169
ML {*
neuper@42386
   170
check_guhs_unique := false; (*WN120307 REMOVE after editing*)
neuper@42289
   171
*}
s1210629013@55359
   172
setup {* KEStore_Elems.add_pbts
s1210629013@55339
   173
  [(prep_pbt @{theory} "pbl_simp_rat_partfrac" [] e_pblID
s1210629013@55339
   174
      (["partial_fraction", "rational", "simplification"],
s1210629013@55339
   175
        [("#Given" ,["functionTerm t_t", "solveFor v_v"]),
s1210629013@55339
   176
          (* TODO: call this sub-problem with appropriate functionTerm: 
s1210629013@55339
   177
            leading coefficient of the denominator is 1: to be checked here! and..
s1210629013@55339
   178
            ("#Where" ,["((get_numerator t_t) has_degree_in v_v) < 
s1210629013@55339
   179
               ((get_denominator t_t) has_degree_in v_v)"]), TODO*)
s1210629013@55339
   180
          ("#Find"  ,["decomposedFunction p_p'''"])],
s1210629013@55339
   181
        append_rls "e_rls" e_rls [(*for preds in where_ TODO*)], 
s1210629013@55339
   182
        NONE, 
s1210629013@55339
   183
        [["simplification","of_rationals","to_partial_fraction"]]))] *}
jan@42354
   184
neuper@42376
   185
subsection {* Method *}
neuper@42376
   186
consts
neuper@42376
   187
  PartFracScript  :: "[real,real,  real] => real" 
neuper@42376
   188
    ("((Script PartFracScript (_ _ =))// (_))" 9)
jan@42353
   189
neuper@42376
   190
text {* rule set for functions called in the Script *}
neuper@42376
   191
ML {*
neuper@42413
   192
  val srls_partial_fraction = Rls {id="srls_partial_fraction", 
neuper@42376
   193
    preconds = [],
neuper@42376
   194
    rew_ord = ("termlessI",termlessI),
neuper@42376
   195
    erls = append_rls "erls_in_srls_partial_fraction" e_rls
neuper@42376
   196
      [(*for asm in NTH_CONS ...*)
neuper@42376
   197
       Calc ("Orderings.ord_class.less",eval_equ "#less_"),
neuper@42376
   198
       (*2nd NTH_CONS pushes n+-1 into asms*)
neuper@42376
   199
       Calc("Groups.plus_class.plus", eval_binop "#add_")], 
neuper@42451
   200
    srls = Erls, calc = [], errpatts = [],
neuper@42376
   201
    rules = [
neuper@42376
   202
       Thm ("NTH_CONS",num_str @{thm NTH_CONS}),
neuper@42376
   203
       Calc("Groups.plus_class.plus", eval_binop "#add_"),
neuper@42376
   204
       Thm ("NTH_NIL",num_str @{thm NTH_NIL}),
neuper@42376
   205
       Calc("Tools.lhs", eval_lhs "eval_lhs_"),
neuper@42376
   206
       Calc("Tools.rhs", eval_rhs"eval_rhs_"),
neuper@42376
   207
       Calc("Atools.argument'_in", eval_argument_in "Atools.argument'_in"),
neuper@42376
   208
       Calc("Rational.get_denominator", eval_get_denominator "#get_denominator"),
neuper@42376
   209
       Calc("Rational.get_numerator", eval_get_numerator "#get_numerator"),
neuper@42376
   210
       Calc("Partial_Fractions.factors_from_solution",
neuper@42376
   211
         eval_factors_from_solution "#factors_from_solution"),
neuper@42376
   212
       Calc("Partial_Fractions.drop_questionmarks", eval_drop_questionmarks "#drop_?")],
neuper@42376
   213
    scr = EmptyScr};
neuper@42376
   214
*}
neuper@42376
   215
ML {*
neuper@42376
   216
eval_drop_questionmarks;
neuper@42376
   217
*}
neuper@42376
   218
ML {*
neuper@48761
   219
val ctxt = Proof_Context.init_global @{theory};
neuper@42376
   220
val SOME t = parseNEW ctxt "eqr = drop_questionmarks eqr";
neuper@42376
   221
*}
neuper@42376
   222
ML {*
neuper@42417
   223
parseNEW ctxt "decomposedFunction p_p'''";
neuper@42376
   224
parseNEW ctxt "decomposedFunction";
neuper@42376
   225
*}
neuper@42415
   226
s1210629013@55380
   227
(* current version, error outcommented *)
s1210629013@55373
   228
setup {* KEStore_Elems.add_mets
s1210629013@55373
   229
  [prep_met @{theory} "met_partial_fraction" [] e_metID
s1210629013@55373
   230
      (["simplification","of_rationals","to_partial_fraction"], 
s1210629013@55373
   231
        [("#Given" ,["functionTerm t_t", "solveFor v_v"]),
s1210629013@55373
   232
          (*("#Where" ,["((get_numerator t_t) has_degree_in v_v) < 
s1210629013@55373
   233
            ((get_denominator t_t) has_degree_in v_v)"]), TODO*)
s1210629013@55373
   234
          ("#Find"  ,["decomposedFunction p_p'''"])],
s1210629013@55373
   235
        (*f_f = 3 / (z * (z - 1 / 4 + -1 / 8 * (1 / z)), zzz: z*)
s1210629013@55373
   236
        {rew_ord'="tless_true", rls'= e_rls, calc = [], srls = srls_partial_fraction, prls = e_rls,
s1210629013@55373
   237
          crls = e_rls, errpats = [], nrls = e_rls},
s1210629013@55373
   238
        (*([], Frm), Problem (Partial_Fractions, [partial_fraction, rational, simplification])*)
s1210629013@55373
   239
        "Script PartFracScript (f_f::real) (zzz::real) =   " ^
s1210629013@55373
   240
          (*([1], Frm), 3 / (z * (z - 1 / 4 + -1 / 8 * (1 / z)))*)
s1210629013@55373
   241
          "(let f_f = Take f_f;                              " ^
s1210629013@55373
   242
          (*           num_orig = 3*)
s1210629013@55373
   243
          "  (num_orig::real) = get_numerator f_f;           " ^
s1210629013@55373
   244
          (*([1], Res), 24 / (-1 + -2 * z + 8 * z ^^^ 2)*)
s1210629013@55373
   245
          "  f_f = (Rewrite_Set norm_Rational False) f_f;    " ^
s1210629013@55373
   246
          (*           denom = -1 + -2 * z + 8 * z ^^^ 2*)
s1210629013@55373
   247
          "  (denom::real) = get_denominator f_f;            " ^
s1210629013@55373
   248
          (*           equ = -1 + -2 * z + 8 * z ^^^ 2 = 0*)
s1210629013@55373
   249
          "  (equ::bool) = (denom = (0::real));              " ^
s1210629013@55373
   250
s1210629013@55373
   251
          (*([2], Pbl), solve (-1 + -2 * z + 8 * z ^^^ 2 = 0, z)*)
s1210629013@55373
   252
          "  (L_L::bool list) = (SubProblem (PolyEq',        " ^
s1210629013@55373
   253
          "    [abcFormula, degree_2, polynomial, univariate, equation], " ^
s1210629013@55373
   254
          (*([2], Res), [z = 1 / 2, z = -1 / 4]*)
s1210629013@55373
   255
          "    [no_met]) [BOOL equ, REAL zzz]);              " ^
s1210629013@55373
   256
          (*           facs: (z - 1 / 2) * (z - -1 / 4)*)
s1210629013@55373
   257
          "  (facs::real) = factors_from_solution L_L;       " ^
s1210629013@55373
   258
          (*([3], Frm), 33 / ((z - 1 / 2) * (z - -1 / 4)) *) 
s1210629013@55373
   259
          "  (eql::real) = Take (num_orig / facs);           " ^
s1210629013@55373
   260
          (*([3], Res), ?A / (z - 1 / 2) + ?B / (z - -1 / 4)*)
s1210629013@55373
   261
          "  (eqr::real) = (Try (Rewrite_Set ansatz_rls False)) eql;  " ^
s1210629013@55373
   262
          (*([4], Frm), 3 / ((z - 1 / 2) * (z - -1 / 4)) = ?A / (z - 1 / 2) + ?B / (z - -1 / 4)*)
s1210629013@55373
   263
          "  (eq::bool) = Take (eql = eqr);                  " ^
s1210629013@55373
   264
          (*([4], Res), 3 = ?A * (z - -1 / 4) + ?B * (z - 1 / 2)*)
s1210629013@55373
   265
          "  eq = (Try (Rewrite_Set equival_trans False)) eq;" ^
s1210629013@55373
   266
          (*           eq = 3 = A * (z - -1 / 4) + B * (z - 1 / 2)*)
s1210629013@55373
   267
          "  eq = drop_questionmarks eq;                     " ^
s1210629013@55373
   268
          (*           z1 = 1 / 2*)
s1210629013@55373
   269
          "  (z1::real) = (rhs (NTH 1 L_L));                 " ^
s1210629013@55373
   270
          (*           z2 = -1 / 4*)
s1210629013@55373
   271
          "  (z2::real) = (rhs (NTH 2 L_L));                 " ^
s1210629013@55373
   272
          (*([5], Frm), 3 = A * (z - -1 / 4) + B * (z - 1 / 2)*)
s1210629013@55373
   273
          "  (eq_a::bool) = Take eq;                         " ^
s1210629013@55373
   274
          (*([5], Res), 3 = A * (1 / 2 - -1 / 4) + B * (1 / 2 - 1 / 2)*)
s1210629013@55373
   275
          "  eq_a = (Substitute [zzz = z1]) eq;              " ^
s1210629013@55373
   276
          (*([6], Res), 3 = 3 * A / 4*)
s1210629013@55373
   277
          "  eq_a = (Rewrite_Set norm_Rational False) eq_a;  " ^
s1210629013@55373
   278
s1210629013@55373
   279
          (*([7], Pbl), solve (3 = 3 * A / 4, A)*)
s1210629013@55373
   280
          "  (sol_a::bool list) =                            " ^
s1210629013@55373
   281
          "    (SubProblem (Isac', [univariate,equation], [no_met])   " ^
s1210629013@55373
   282
          (*([7], Res), [A = 4]*)
s1210629013@55373
   283
          "    [BOOL eq_a, REAL (A::real)]);                 " ^
s1210629013@55373
   284
          (*           a = 4*)
s1210629013@55373
   285
          "  (a::real) = (rhs (NTH 1 sol_a));                " ^
s1210629013@55373
   286
          (*([8], Frm), 3 = A * (z - -1 / 4) + B * (z - 1 / 2)*)
s1210629013@55373
   287
          "  (eq_b::bool) = Take eq;                         " ^
s1210629013@55373
   288
          (*([8], Res), 3 = A * (-1 / 4 - -1 / 4) + B * (-1 / 4 - 1 / 2)*)
s1210629013@55373
   289
          "  eq_b = (Substitute [zzz = z2]) eq_b;            " ^
s1210629013@55373
   290
          (*([9], Res), 3 = -3 * B / 4*)
s1210629013@55373
   291
          "  eq_b = (Rewrite_Set norm_Rational False) eq_b;  " ^
s1210629013@55373
   292
          (*([10], Pbl), solve (3 = -3 * B / 4, B)*)
s1210629013@55373
   293
          "  (sol_b::bool list) =                            " ^
s1210629013@55373
   294
          "    (SubProblem (Isac', [univariate,equation], [no_met])   " ^
s1210629013@55373
   295
          (*([10], Res), [B = -4]*)
s1210629013@55373
   296
          "    [BOOL eq_b, REAL (B::real)]);                 " ^
s1210629013@55373
   297
          (*           b = -4*)
s1210629013@55373
   298
          "  (b::real) = (rhs (NTH 1 sol_b));                " ^
s1210629013@55373
   299
          (*           eqr = A / (z - 1 / 2) + B / (z - -1 / 4)*)
s1210629013@55373
   300
          "  eqr = drop_questionmarks eqr;                   " ^
s1210629013@55373
   301
          (*([11], Frm), A / (z - 1 / 2) + B / (z - -1 / 4)*)
s1210629013@55373
   302
          "  (pbz::real) = Take eqr;                         " ^
s1210629013@55373
   303
          (*([11], Res), 4 / (z - 1 / 2) + -4 / (z - -1 / 4)*)
s1210629013@55373
   304
          "  pbz = ((Substitute [A = a, B = b]) pbz)         " ^
s1210629013@55373
   305
          (*([], Res), 4 / (z - 1 / 2) + -4 / (z - -1 / 4)*)
s1210629013@55373
   306
          "in pbz)"
s1210629013@55373
   307
)]
s1210629013@55373
   308
*}
neuper@42376
   309
ML {*
neuper@42376
   310
(*
neuper@42376
   311
  val fmz =                                             
neuper@42376
   312
    ["functionTerm (3 / (z * (z - 1 / 4 + -1 / 8 * (1 / z))))", 
neuper@42376
   313
      "solveFor z", "functionTerm p_p"];
neuper@42376
   314
  val (dI',pI',mI') =
neuper@42376
   315
    ("Partial_Fractions", 
neuper@42376
   316
      ["partial_fraction", "rational", "simplification"],
neuper@42376
   317
      ["simplification","of_rationals","to_partial_fraction"]);
neuper@42376
   318
  val (p,_,f,nxt,_,pt) = CalcTreeTEST [(fmz, (dI',pI',mI'))];
neuper@42376
   319
*)
neuper@42376
   320
*}
neuper@42289
   321
jan@42295
   322
neuper@42376
   323
neuper@42376
   324
subsection {**}
neuper@42376
   325
neuper@42289
   326
end