(* rationals, fractions of multivariate polynomials over the real field

   author: isac team

   Copyright (c) isac team 2002, 2013

   Use is subject to license terms.

   depends on Poly (and not on Atools), because 

   fractions with _normalised_ polynomials are canceled, added, etc.

*)

theory Rational 

imports Poly GCD_Poly_ML

begin

section \<open>Constants for evaluation by "Rule.Eval"\<close>

consts

  is_expanded    :: "real => bool" ("_ is'_expanded")     (*RL->Poly.thy*)

  is_ratpolyexp  :: "real => bool" ("_ is'_ratpolyexp") 

  get_denominator :: "real => real"

  get_numerator   :: "real => real"           

ML \<open>

(*.the expression contains + - * ^ / only ?.*)

fun is_ratpolyexp (Free _) = true

  | is_ratpolyexp (Const (\<^const_name>\<open>plus\<close>,_) $ Free _ $ Free _) = true

  | is_ratpolyexp (Const (\<^const_name>\<open>minus\<close>,_) $ Free _ $ Free _) = true

  | is_ratpolyexp (Const (\<^const_name>\<open>times\<close>,_) $ Free _ $ Free _) = true

  | is_ratpolyexp (Const (\<^const_name>\<open>powr\<close>,_) $ Free _ $ Free _) = true

  | is_ratpolyexp (Const (\<^const_name>\<open>divide\<close>,_) $ Free _ $ Free _) = true

  | is_ratpolyexp (Const (\<^const_name>\<open>plus\<close>,_) $ t1 $ t2) = 

               ((is_ratpolyexp t1) andalso (is_ratpolyexp t2))

  | is_ratpolyexp (Const (\<^const_name>\<open>minus\<close>,_) $ t1 $ t2) = 

               ((is_ratpolyexp t1) andalso (is_ratpolyexp t2))

  | is_ratpolyexp (Const (\<^const_name>\<open>times\<close>,_) $ t1 $ t2) = 

               ((is_ratpolyexp t1) andalso (is_ratpolyexp t2))

  | is_ratpolyexp (Const (\<^const_name>\<open>powr\<close>,_) $ t1 $ t2) = 

               ((is_ratpolyexp t1) andalso (is_ratpolyexp t2))

  | is_ratpolyexp (Const (\<^const_name>\<open>divide\<close>,_) $ t1 $ t2) = 

               ((is_ratpolyexp t1) andalso (is_ratpolyexp t2))

  | is_ratpolyexp _ = false;

(*("is_ratpolyexp", ("Rational.is_ratpolyexp", eval_is_ratpolyexp ""))*)

fun eval_is_ratpolyexp (thmid:string) _ 

		       (t as (Const("Rational.is_ratpolyexp", _) $ arg)) thy =

    if is_ratpolyexp arg

    then SOME (TermC.mk_thmid thmid (UnparseC.term_in_thy thy arg) "", 

	         HOLogic.Trueprop $ (TermC.mk_equality (t, @{term True})))

    else SOME (TermC.mk_thmid thmid (UnparseC.term_in_thy thy arg) "", 

	         HOLogic.Trueprop $ (TermC.mk_equality (t, @{term False})))

  | eval_is_ratpolyexp _ _ _ _ = NONE; 

(*("get_denominator", ("Rational.get_denominator", eval_get_denominator ""))*)

fun eval_get_denominator (thmid:string) _ 

		      (t as Const ("Rational.get_denominator", _) $

              (Const (\<^const_name>\<open>divide\<close>, _) $ _(*num*) $

                denom)) thy = 

      SOME (TermC.mk_thmid thmid (UnparseC.term_in_thy thy denom) "", 

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

  | eval_get_denominator _ _ _ _ = NONE; 

(*("get_numerator", ("Rational.get_numerator", eval_get_numerator ""))*)

fun eval_get_numerator (thmid:string) _ 

      (t as Const ("Rational.get_numerator", _) $

          (Const (\<^const_name>\<open>divide\<close>, _) $num

            $denom )) thy = 

    SOME (TermC.mk_thmid thmid (UnparseC.term_in_thy thy num) "", 

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

  | eval_get_numerator _ _ _ _ = NONE; 

\<close>

section \<open>Theorems for rewriting\<close>

axiomatization (* naming due to Isabelle2002, but not contained in Isabelle2002; 

                  many thms are due to RL and can be removed with updating the equation solver;

                  TODO: replace by equivalent thms in recent Isabelle201x *) 

where

  mult_cross:      "[| b ~= 0; d ~= 0 |] ==> (a / b = c / d) = (a * d = b * c)" and

  mult_cross1:     "   b ~= 0            ==> (a / b = c    ) = (a     = b * c)" and

  mult_cross2:     "           d ~= 0    ==> (a     = c / d) = (a * d =     c)" and

  add_minus:       "a + b - b = a"(*RL->Poly.thy*) and

  add_minus1:      "a - b + b = a"(*RL->Poly.thy*) and

  rat_mult:        "a / b * (c / d) = a * c / (b * d)"(*?Isa02*)  and

  rat_mult2:       "a / b *  c      = a * c /  b     "(*?Isa02*) and

  rat_mult_poly_l: "c is_polyexp ==> c * (a / b) = c * a /  b" and

  rat_mult_poly_r: "c is_polyexp ==> (a / b) * c = a * c /  b" and

(*real_times_divide1_eq .. Isa02*) 

  real_times_divide_1_eq:  "-1 * (c / d) = -1 * c / d " and

  real_times_divide_num:   "a is_const ==> a * (c / d) = a * c / d " and

  real_mult_div_cancel2:   "k ~= 0 ==> m * k / (n * k) = m / n" and

(*real_mult_div_cancel1:   "k ~= 0 ==> k * m / (k * n) = m / n"..Isa02*)

  real_divide_divide1:     "y ~= 0 ==> (u / v) / (y / z) = (u / v) * (z / y)" and

  real_divide_divide1_mg:  "y ~= 0 ==> (u / v) / (y / z) = (u * z) / (y * v)" and

(*real_divide_divide2_eq:  "x / y / z = x / (y * z)"..Isa02*)

  rat_power:               "(a / b) \<up> n = (a \<up> n) / (b \<up> n)" and

  rat_add:         "[| a is_const; b is_const; c is_const; d is_const |] ==> 

	           a / c + b / d = (a * d + b * c) / (c * d)" and

  rat_add_assoc:   "[| a is_const; b is_const; c is_const; d is_const |] ==> 

	           a / c +(b / d + e) = (a * d + b * c)/(d * c) + e" and

  rat_add1:        "[| a is_const; b is_const; c is_const |] ==> 

	           a / c + b / c = (a + b) / c" and

  rat_add1_assoc:   "[| a is_const; b is_const; c is_const |] ==> 

	           a / c + (b / c + e) = (a + b) / c + e" and

  rat_add2:        "[| a is_const; b is_const; c is_const |] ==> 

	           a / c + b = (a + b * c) / c" and

  rat_add2_assoc:  "[| a is_const; b is_const; c is_const |] ==> 

	           a / c + (b + e) = (a + b * c) / c + e" and

  rat_add3:        "[| a is_const; b is_const; c is_const |] ==> 

	           a + b / c = (a * c + b) / c" and

  rat_add3_assoc:   "[| a is_const; b is_const; c is_const |] ==> 

	           a + (b / c + e) = (a * c + b) / c + e"

section \<open>Cancellation and addition of fractions\<close>

subsection \<open>Conversion term <--> poly\<close>

subsubsection \<open>Convert a term to the internal representation of a multivariate polynomial\<close>

ML \<open>

fun monom_of_term vs (c, es) (t as Const _) =

    (c, list_update es (find_index (curry op = t) vs) 1)

  | monom_of_term  vs (c, es) (t as Free (id, _)) =

    if TermC.is_num' id 

    then (id |> TermC.int_opt_of_string |> the |> curry op * c, es) (*several numerals in one monom*)

    else (c, list_update es (find_index (curry op = t) vs) 1)

  | monom_of_term  vs (c, es) (Const (\<^const_name>\<open>powr\<close>, _) $ (t as Free _) $ Free (e, _)) =

    (c, list_update es (find_index (curry op = t) vs) (the (TermC.int_opt_of_string e)))

  | monom_of_term vs (c, es) (Const (\<^const_name>\<open>times\<close>, _) $ m1 $ m2) =

    let val (c', es') = monom_of_term vs (c, es) m1

    in monom_of_term vs (c', es') m2 end

  | monom_of_term _ _ t = raise ERROR ("poly malformed 1 with " ^ UnparseC.term t)

fun monoms_of_term vs (t as Const _) =

    [monom_of_term  vs (1, replicate (length vs) 0) t]

  | monoms_of_term vs (t as Free _) =

    [monom_of_term  vs (1, replicate (length vs) 0) t]

  | monoms_of_term vs (t as Const (\<^const_name>\<open>powr\<close>, _) $ _ $  _) =

    [monom_of_term  vs (1, replicate (length vs) 0) t]

  | monoms_of_term vs (t as Const (\<^const_name>\<open>times\<close>, _) $ _ $  _) =

    [monom_of_term  vs (1, replicate (length vs) 0) t]

  | monoms_of_term vs (Const (\<^const_name>\<open>plus\<close>, _) $ ms1 $ ms2) =

    (monoms_of_term vs ms1) @ (monoms_of_term vs ms2)

  | monoms_of_term _ t = raise ERROR ("poly malformed 2 with " ^ UnparseC.term t)

(* convert a term to the internal representation of a multivariate polynomial;

  the conversion is quite liberal, see test --- fun poly_of_term ---:

* the order of variables and the parentheses within a monomial are arbitrary

* the coefficient may be somewhere

* he order and the parentheses within monomials are arbitrary

But the term must be completely expand + over * (laws of distributivity are not applicable).

The function requires the free variables as strings already given, 

because the gcd involves 2 polynomials (with the same length for their list of exponents).

*)

fun poly_of_term vs (t as Const (\<^const_name>\<open>plus\<close>, _) $ _ $ _) =

    (SOME (t |> monoms_of_term vs |> order)

      handle ERROR _ => NONE)

  | poly_of_term vs t =

    (SOME [monom_of_term vs (1, replicate (length vs) 0) t]

      handle ERROR _ => NONE)

fun is_poly t =

  let

    val vs = TermC.vars_of t

  in 

    case poly_of_term vs t of SOME _ => true | NONE => false

  end

val is_expanded = is_poly   (* TODO: check names *)

val is_polynomial = is_poly (* TODO: check names *)

\<close>

subsubsection \<open>Convert internal representation of a multivariate polynomial to a term\<close>

ML \<open>

fun term_of_es _ _ _ [] = [] (*assumes same length for vs and es*)

  | term_of_es baseT expT (_ :: vs) (0 :: es) = [] @ term_of_es baseT expT vs es

  | term_of_es baseT expT (v :: vs) (1 :: es) = v :: term_of_es baseT expT vs es

  | term_of_es baseT expT (v :: vs) (e :: es) =

    Const (\<^const_name>\<open>powr\<close>, [baseT, expT] ---> baseT) $ v $  (Free (TermC.isastr_of_int e, expT))

    :: term_of_es baseT expT vs es

  | term_of_es _ _ _ _ = raise ERROR "term_of_es: length vs <> length es"

fun term_of_monom baseT expT vs ((c, es): monom) =

    let val es' = term_of_es baseT expT vs es

    in 

      if c = 1 

      then 

        if es' = [] (*if es = [0,0,0,...]*)

        then Free (TermC.isastr_of_int c, baseT)

        else foldl (HOLogic.mk_binop \<^const_name>\<open>times\<close>) (hd es', tl es')

      else foldl (HOLogic.mk_binop \<^const_name>\<open>times\<close>) (Free (TermC.isastr_of_int c, baseT), es') 

    end

fun term_of_poly baseT expT vs p =

  let val monos = map (term_of_monom baseT expT vs) p

  in foldl (HOLogic.mk_binop \<^const_name>\<open>plus\<close>) (hd monos, tl monos) end

\<close>

subsection \<open>Apply gcd_poly for cancelling and adding fractions as terms\<close>

ML \<open>

fun mk_noteq_0 baseT t = 

  Const (\<^const_name>\<open>Not\<close>, HOLogic.boolT --> HOLogic.boolT) $ 

    (Const (\<^const_name>\<open>HOL.eq\<close>, [baseT, baseT] ---> HOLogic.boolT) $ t $ Free ("0", HOLogic.realT))

fun mk_asms baseT ts =

  let val as' = filter_out TermC.is_num ts (* asm like "2 ~= 0" is needless *)

  in map (mk_noteq_0 baseT) as' end

\<close>

subsubsection \<open>Factor out gcd for cancellation\<close>

ML \<open>

fun check_fraction t =

  case t of

    Const (\<^const_name>\<open>divide\<close>, _) $ numerator $ denominator

      => SOME (numerator, denominator)

  | _ => NONE

(* prepare a term for cancellation by factoring out the gcd

  assumes: is a fraction with outmost "/"*)

fun factout_p_ (thy: theory) t =

  let val opt = check_fraction t

  in

    case opt of 

      NONE => NONE

    | SOME (numerator, denominator) =>

      let

        val vs = TermC.vars_of t

        val baseT = type_of numerator

        val expT = HOLogic.realT

      in

        case (poly_of_term vs numerator, poly_of_term vs denominator) of

          (SOME a, SOME b) =>

            let

              val ((a', b'), c) = gcd_poly a b

              val es = replicate (length vs) 0 

            in

              if c = [(1, es)] orelse c = [(~1, es)]

              then NONE

              else 

                let

                  val b't = term_of_poly baseT expT vs b'

                  val ct = term_of_poly baseT expT vs c

                  val t' = 

                    HOLogic.mk_binop \<^const_name>\<open>divide\<close> 

                      (HOLogic.mk_binop \<^const_name>\<open>times\<close>

                        (term_of_poly baseT expT vs a', ct),

                       HOLogic.mk_binop \<^const_name>\<open>times\<close> (b't, ct))

                in SOME (t', mk_asms baseT [b't, ct]) end

            end

        | _ => NONE : (term * term list) option

      end

  end

\<close>

subsubsection \<open>Cancel a fraction\<close>

ML \<open>

(* cancel a term by the gcd ("" denote terms with internal algebraic structure)

  cancel_p_ :: theory \<Rightarrow> term  \<Rightarrow> (term \<times> term list) option

  cancel_p_ thy "a / b" = SOME ("a' / b'", ["b' \<noteq> 0"])

  assumes: a is_polynomial  \<and>  b is_polynomial  \<and>  b \<noteq> 0

  yields

    SOME ("a' / b'", ["b' \<noteq> 0"]). gcd_poly a b \<noteq> 1  \<and>  gcd_poly a b \<noteq> -1  \<and>  

      a' * gcd_poly a b = a  \<and>  b' * gcd_poly a b = b

    \<or> NONE *)

fun cancel_p_ (_: theory) t =

  let val opt = check_fraction t

  in

    case opt of 

      NONE => NONE

    | SOME (numerator, denominator) =>

      let

        val vs = TermC.vars_of t

        val baseT = type_of numerator

        val expT = HOLogic.realT

      in

        case (poly_of_term vs numerator, poly_of_term vs denominator) of

          (SOME a, SOME b) =>

            let

              val ((a', b'), c) = gcd_poly a b

              val es = replicate (length vs) 0 

            in

              if c = [(1, es)] orelse c = [(~1, es)]

              then NONE

              else 

                let

                  val bt' = term_of_poly baseT expT vs b'

                  val ct = term_of_poly baseT expT vs c

                  val t' = 

                    HOLogic.mk_binop \<^const_name>\<open>divide\<close> 

                      (term_of_poly baseT expT vs a', bt')

                  val asm = mk_asms baseT [bt']

                in SOME (t', asm) end

            end

        | _ => NONE : (term * term list) option

      end

  end

\<close>

subsubsection \<open>Factor out to a common denominator for addition\<close>

ML \<open>

(* addition of fractions allows (at most) one non-fraction (a monomial) *)

fun check_frac_sum 

    (Const (\<^const_name>\<open>plus\<close>, _) $ 

      (Const (\<^const_name>\<open>divide\<close>, _) $ n1 $ d1) $

      (Const (\<^const_name>\<open>divide\<close>, _) $ n2 $ d2))

    = SOME ((n1, d1), (n2, d2))

  | check_frac_sum 

    (Const (\<^const_name>\<open>plus\<close>, _) $ 

      nofrac $ 

      (Const (\<^const_name>\<open>divide\<close>, _) $ n2 $ d2))

    = SOME ((nofrac, Free ("1", HOLogic.realT)), (n2, d2))

  | check_frac_sum 

    (Const (\<^const_name>\<open>plus\<close>, _) $ 

      (Const (\<^const_name>\<open>divide\<close>, _) $ n1 $ d1) $ 

      nofrac)

    = SOME ((n1, d1), (nofrac, Free ("1", HOLogic.realT)))

  | check_frac_sum _ = NONE  

(* prepare a term for addition by providing the least common denominator as a product

  assumes: is a term with outmost "+" and at least one outmost "/" in respective summands*)

fun common_nominator_p_ (_: theory) t =

  let val opt = check_frac_sum t

  in

    case opt of 

      NONE => NONE

    | SOME ((n1, d1), (n2, d2)) =>

      let

        val vs = TermC.vars_of t

      in

        case (poly_of_term vs d1, poly_of_term vs d2) of

          (SOME a, SOME b) =>

            let

              val ((a', b'), c) = gcd_poly a b

              val (baseT, expT) = (type_of n1, HOLogic.realT)

              val [d1', d2', c'] = map (term_of_poly baseT expT vs) [a', b', c]

              (*----- minimum of parentheses & nice result, but breaks tests: -------------

              val denom = HOLogic.mk_binop \<^const_name>\<open>times\<close> 

                (HOLogic.mk_binop \<^const_name>\<open>times\<close> (d1', d2'), c') -------------*)

              val denom =

                if c = [(1, replicate (length vs) 0)]

                then HOLogic.mk_binop \<^const_name>\<open>times\<close> (d1', d2')

                else

                  HOLogic.mk_binop \<^const_name>\<open>times\<close> (c',

                  HOLogic.mk_binop \<^const_name>\<open>times\<close> (d1', d2')) (*--------------*)

              val t' =

                HOLogic.mk_binop \<^const_name>\<open>plus\<close>

                  (HOLogic.mk_binop \<^const_name>\<open>divide\<close>

                    (HOLogic.mk_binop \<^const_name>\<open>times\<close> (n1, d2'), denom),

                  HOLogic.mk_binop \<^const_name>\<open>divide\<close> 

                    (HOLogic.mk_binop \<^const_name>\<open>times\<close> (n2, d1'), denom))

              val asm = mk_asms baseT [d1', d2', c']

            in SOME (t', asm) end

        | _ => NONE : (term * term list) option

      end

  end

\<close>

subsubsection \<open>Addition of at least one fraction within a sum\<close>

ML \<open>

(* add fractions

  assumes: is a term with outmost "+" and at least one outmost "/" in respective summands

  NOTE: the case "(_ + _) + _" need not be considered due to iterated addition.*)

fun add_fraction_p_ (_: theory) t =

  case check_frac_sum t of 

    NONE => NONE

  | SOME ((n1, d1), (n2, d2)) =>

    let

      val vs = TermC.vars_of t

    in

      case (poly_of_term vs n1, poly_of_term vs d1, poly_of_term vs n2, poly_of_term vs d2) of

        (SOME _, SOME a, SOME _, SOME b) =>

          let

            val ((a', b'), c) = gcd_poly a b

            val (baseT, expT) = (type_of n1, HOLogic.realT)

            val nomin = term_of_poly baseT expT vs 

              (((the (poly_of_term vs n1)) %%*%% b') %%+%% ((the (poly_of_term vs n2)) %%*%% a')) 

            val denom = term_of_poly baseT expT vs ((c %%*%% a') %%*%% b')

            val t' = HOLogic.mk_binop \<^const_name>\<open>divide\<close> (nomin, denom)

          in SOME (t', mk_asms baseT [denom]) end

      | _ => NONE : (term * term list) option

    end

\<close>

section \<open>Embed cancellation and addition into rewriting\<close>

subsection \<open>Rulesets and predicate for embedding\<close>

ML \<open>

(* evaluates conditions in calculate_Rational *)

val calc_rat_erls =

  prep_rls'

    (Rule_Def.Repeat {id = "calc_rat_erls", preconds = [], rew_ord = ("dummy_ord", Rewrite_Ord.dummy_ord), 

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

      rules = 

        [\<^rule_eval>\<open>HOL.eq\<close> (Prog_Expr.eval_equal "#equal_"),

        \<^rule_eval>\<open>Prog_Expr.is_const\<close> (Prog_Expr.eval_const "#is_const_"),

        \<^rule_thm>\<open>not_true\<close>,

        \<^rule_thm>\<open>not_false\<close>], 

      scr = Rule.Empty_Prog});

(* simplifies expressions with numerals;

   does NOT rearrange the term by AC-rewriting; thus terms with variables 

   need to have constants to be commuted together respectively           *)

val calculate_Rational =

  prep_rls' (Rule_Set.merge "calculate_Rational"

    (Rule_Def.Repeat {id = "divide", preconds = [], rew_ord = ("dummy_ord", Rewrite_Ord.dummy_ord), 

      erls = calc_rat_erls, srls = Rule_Set.Empty,

      calc = [], errpatts = [],

      rules = 

        [\<^rule_eval>\<open>divide\<close> (Prog_Expr.eval_cancel "#divide_e"),

        Rule.Thm ("minus_divide_left", ThmC.numerals_to_Free (@{thm minus_divide_left} RS @{thm sym})),

          (*SYM - ?x / ?y = - (?x / ?y)  may come from subst*)

        \<^rule_thm>\<open>rat_add\<close>,

          (*"[| a is_const; b is_const; c is_const; d is_const |] ==> \

          \a / c + b / d = (a * d) / (c * d) + (b * c ) / (d * c)"*)

        \<^rule_thm>\<open>rat_add1\<close>,

          (*"[| a is_const; b is_const; c is_const |] ==> a / c + b / c = (a + b) / c"*)

        \<^rule_thm>\<open>rat_add2\<close>,

          (*"[| ?a is_const; ?b is_const; ?c is_const |] ==> ?a / ?c + ?b = (?a + ?b * ?c) / ?c"*)

        \<^rule_thm>\<open>rat_add3\<close>,

          (*"[| a is_const; b is_const; c is_const |] ==> a + b / c = (a * c) / c + b / c"\

          .... is_const to be omitted here FIXME*)

        \<^rule_thm>\<open>rat_mult\<close>, 

          (*a / b * (c / d) = a * c / (b * d)*)

        \<^rule_thm>\<open>times_divide_eq_right\<close>,

          (*?x * (?y / ?z) = ?x * ?y / ?z*)

        \<^rule_thm>\<open>times_divide_eq_left\<close>,

          (*?y / ?z * ?x = ?y * ?x / ?z*)

        \<^rule_thm>\<open>real_divide_divide1\<close>,

          (*"?y ~= 0 ==> ?u / ?v / (?y / ?z) = ?u / ?v * (?z / ?y)"*)

        \<^rule_thm>\<open>divide_divide_eq_left\<close>,

          (*"?x / ?y / ?z = ?x / (?y * ?z)"*)

        \<^rule_thm>\<open>rat_power\<close>,

          (*"(?a / ?b)  \<up>  ?n = ?a  \<up>  ?n / ?b  \<up>  ?n"*)

        \<^rule_thm>\<open>mult_cross\<close>,

          (*"[| b ~= 0; d ~= 0 |] ==> (a / b = c / d) = (a * d = b * c)*)

        \<^rule_thm>\<open>mult_cross1\<close>,

          (*"   b ~= 0            ==> (a / b = c    ) = (a     = b * c)*)

        \<^rule_thm>\<open>mult_cross2\<close>

          (*"           d ~= 0    ==> (a     = c / d) = (a * d =     c)*)], 

      scr = Rule.Empty_Prog})

    calculate_Poly);

(*("is_expanded", ("Rational.is_expanded", eval_is_expanded ""))*)

fun eval_is_expanded (thmid:string) _ 

		       (t as (Const("Rational.is_expanded", _) $ arg)) thy = 

    if is_expanded arg

    then SOME (TermC.mk_thmid thmid (UnparseC.term_in_thy thy arg) "", 

	         HOLogic.Trueprop $ (TermC.mk_equality (t, @{term True})))

    else SOME (TermC.mk_thmid thmid (UnparseC.term_in_thy thy arg) "", 

	         HOLogic.Trueprop $ (TermC.mk_equality (t, @{term False})))

  | eval_is_expanded _ _ _ _ = NONE;

\<close>

calculation is_expanded = \<open>eval_is_expanded ""\<close>

ML \<open>

val rational_erls = 

  Rule_Set.merge "rational_erls" calculate_Rational 

    (Rule_Set.append_rules "is_expanded" Atools_erls 

      [\<^rule_eval>\<open>is_expanded\<close> (eval_is_expanded "")]);

\<close>

subsection \<open>Embed cancellation into rewriting\<close>

ML \<open>

(**)local (* cancel_p *)

val {rules = rules, rew_ord = (_, ro), ...} = Rule_Set.rep (assoc_rls' @{theory} "rev_rew_p");

fun init_state thy eval_rls ro t =

  let

    val SOME (t', _) = factout_p_ thy t;

    val SOME (t'', asm) = cancel_p_ thy t;

    val der = Derive.steps_reverse thy eval_rls rules ro NONE t';

    val der = der @ 

      [(\<^rule_thm>\<open>real_mult_div_cancel2\<close>, (t'', asm))]

    val rs = (Rule.distinct' o (map #1)) der

  	val rs = filter_out (ThmC.member'

  	  ["sym_real_add_zero_left", "sym_real_mult_0", "sym_real_mult_1"]) rs

  in (t, t'', [rs(*one in order to ease locate_rule*)], der) end;

fun locate_rule thy eval_rls ro [rs] t r =

    if member op = ((map (Rule.thm_id)) rs) (Rule.thm_id r)

    then 

      let val ropt = Rewrite.rewrite_ thy ro eval_rls true (Rule.thm r) t;

      in

        case ropt of SOME ta => [(r, ta)]

	      | NONE => ((*tracing 

	          ("### locate_rule:  rewrite " ^ Rule.thm_id r ^ " " ^ UnparseC.term t ^ " = NONE");*) []) 

			end

    else ((*tracing ("### locate_rule:  " ^ Rule.thm_id r ^ " not mem rrls");*) [])

  | locate_rule _ _ _ _ _ _ = raise ERROR "locate_rule: doesnt match rev-sets in istate";

fun next_rule thy eval_rls ro [rs] t =

    let

      val der = Derive.do_one thy eval_rls rs ro NONE t;

    in case der of (_, r, _) :: _ => SOME r | _ => NONE end

  | next_rule _ _ _ _ _ = raise ERROR ("next_rule: doesnt match rev-sets in istate");

fun attach_form (_: Rule.rule list list) (_: term) (_: term) = 

  [(*TODO*)]: ( Rule.rule * (term * term list)) list;

(**)in(**)

val cancel_p = 

  Rule_Set.Rrls {id = "cancel_p", prepat = [],

	rew_ord=("ord_make_polynomial", ord_make_polynomial false \<^theory>),

	erls = rational_erls, 

	calc = 

	  [("PLUS", (\<^const_name>\<open>plus\<close>, (**)eval_binop "#add_")),

	  ("TIMES" , (\<^const_name>\<open>times\<close>, (**)eval_binop "#mult_")),

	  ("DIVIDE", (\<^const_name>\<open>divide\<close>, Prog_Expr.eval_cancel "#divide_e")),

	  ("POWER", (\<^const_name>\<open>powr\<close>, (**)eval_binop "#power_"))],

    errpatts = [],

	scr =

	  Rule.Rfuns {init_state  = init_state \<^theory> Atools_erls ro,

		normal_form = cancel_p_ \<^theory>, 

		locate_rule = locate_rule \<^theory> Atools_erls ro,

		next_rule   = next_rule \<^theory> Atools_erls ro,

		attach_form = attach_form}}

(**)end(* local cancel_p *)

\<close>

subsection \<open>Embed addition into rewriting\<close>

ML \<open>

(**)local (* add_fractions_p *)

(*val {rules = rules, rew_ord = (_, ro), ...} = Rule_Set.rep (assoc_rls "make_polynomial");*)

val {rules, rew_ord=(_,ro),...} = Rule_Set.rep (assoc_rls' @{theory} "rev_rew_p");

fun init_state thy eval_rls ro t =

  let 

    val SOME (t',_) = common_nominator_p_ thy t;

    val SOME (t'', asm) = add_fraction_p_ thy t;

    val der = Derive.steps_reverse thy eval_rls rules ro NONE t';

    val der = der @ 

      [(\<^rule_thm>\<open>real_mult_div_cancel2\<close>, (t'',asm))]

    val rs = (Rule.distinct' o (map #1)) der;

    val rs = filter_out (ThmC.member'

      ["sym_real_add_zero_left", "sym_real_mult_0", "sym_real_mult_1"]) rs;

  in (t, t'', [rs(*here only _ONE_*)], der) end;

fun locate_rule thy eval_rls ro [rs] t r =

    if member op = ((map (Rule.thm_id)) rs) (Rule.thm_id r)

    then 

      let val ropt = Rewrite.rewrite_ thy ro eval_rls true (Rule.thm r) t;

      in 

        case ropt of

          SOME ta => [(r, ta)]

	      | NONE => 

	        ((*tracing ("### locate_rule:  rewrite " ^ Rule.thm_id r ^ " " ^ UnparseC.term t ^ " = NONE");*)

	        []) end

    else ((*tracing ("### locate_rule:  " ^ Rule.thm_id r ^ " not mem rrls");*) [])

  | locate_rule _ _ _ _ _ _ = raise ERROR "locate_rule: doesnt match rev-sets in istate";

fun next_rule thy eval_rls ro [rs] t =

    let val der = Derive.do_one thy eval_rls rs ro NONE t;

    in 

      case der of

	      (_,r,_)::_ => SOME r

	    | _ => NONE

    end

  | next_rule _ _ _ _ _ = raise ERROR ("next_rule: doesnt match rev-sets in istate");

val pat0 = TermC.parse_patt \<^theory> "?r/?s+?u/?v :: real";

val pat1 = TermC.parse_patt \<^theory> "?r/?s+?u    :: real";

val pat2 = TermC.parse_patt \<^theory> "?r   +?u/?v :: real";

val prepat = [([@{term True}], pat0),

	      ([@{term True}], pat1),

	      ([@{term True}], pat2)];

(**)in(**)

val add_fractions_p =

  Rule_Set.Rrls {id = "add_fractions_p", prepat=prepat,

    rew_ord = ("ord_make_polynomial", ord_make_polynomial false \<^theory>),

    erls = rational_erls,

    calc = [("PLUS", (\<^const_name>\<open>plus\<close>, (**)eval_binop "#add_")),

      ("TIMES", (\<^const_name>\<open>times\<close>, (**)eval_binop "#mult_")),

      ("DIVIDE", (\<^const_name>\<open>divide\<close>, Prog_Expr.eval_cancel "#divide_e")),

      ("POWER", (\<^const_name>\<open>powr\<close>, (**)eval_binop "#power_"))],

    errpatts = [],

    scr = Rule.Rfuns {init_state  = init_state \<^theory> Atools_erls ro,

      normal_form = add_fraction_p_ \<^theory>,

      locate_rule = locate_rule \<^theory> Atools_erls ro,

      next_rule   = next_rule \<^theory> Atools_erls ro,

      attach_form = attach_form}}

(**)end(*local add_fractions_p *)

\<close>

subsection \<open>Cancelling and adding all occurrences in a term /////////////////////////////\<close>

ML \<open>

(*copying cancel_p_rls + add her caused error in interface.sml*)

\<close>

section \<open>Rulesets for general simplification\<close>

ML \<open>

(*erls for calculate_Rational; make local with FIXX@ME result:term *term list*)

val powers_erls = prep_rls'(

  Rule_Def.Repeat {id = "powers_erls", preconds = [], rew_ord = ("dummy_ord",Rewrite_Ord.dummy_ord), 

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

      rules = [\<^rule_eval>\<open>Prog_Expr.is_atom\<close> (Prog_Expr.eval_is_atom "#is_atom_"),

	       \<^rule_eval>\<open>Prog_Expr.is_even\<close> (Prog_Expr.eval_is_even "#is_even_"),

	       \<^rule_eval>\<open>less\<close> (Prog_Expr.eval_equ "#less_"),

	       \<^rule_thm>\<open>not_false\<close>,

	       \<^rule_thm>\<open>not_true\<close>,

	       \<^rule_eval>\<open>plus\<close> (**)(eval_binop "#add_")

	       ],

      scr = Rule.Empty_Prog

      });

(*.all powers over + distributed; atoms over * collected, other distributed

   contains absolute minimum of thms for context in norm_Rational .*)

val powers = prep_rls'(

  Rule_Def.Repeat {id = "powers", preconds = [], rew_ord = ("dummy_ord",Rewrite_Ord.dummy_ord), 

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

      rules = [\<^rule_thm>\<open>realpow_multI\<close>,

	       (*"(r * s)  \<up>  n = r  \<up>  n * s  \<up>  n"*)

	       \<^rule_thm>\<open>realpow_pow\<close>,

	       (*"(a  \<up>  b)  \<up>  c = a  \<up>  (b * c)"*)

	       \<^rule_thm>\<open>realpow_oneI\<close>,

	       (*"r  \<up>  1 = r"*)

	       \<^rule_thm>\<open>realpow_minus_even\<close>,

	       (*"n is_even ==> (- r)  \<up>  n = r  \<up>  n" ?-->discard_minus?*)

	       \<^rule_thm>\<open>realpow_minus_odd\<close>,

	       (*"Not (n is_even) ==> (- r)  \<up>  n = -1 * r  \<up>  n"*)

	       (*----- collect atoms over * -----*)

	       \<^rule_thm>\<open>realpow_two_atom\<close>,	

	       (*"r is_atom ==> r * r = r  \<up>  2"*)

	       \<^rule_thm>\<open>realpow_plus_1\<close>,		

	       (*"r is_atom ==> r * r  \<up>  n = r  \<up>  (n + 1)"*)

	       \<^rule_thm>\<open>realpow_addI_atom\<close>,

	       (*"r is_atom ==> r  \<up>  n * r  \<up>  m = r  \<up>  (n + m)"*)

	       (*----- distribute none-atoms -----*)

	       \<^rule_thm>\<open>realpow_def_atom\<close>,

	       (*"[| 1 < n; ~ (r is_atom) |]==>r  \<up>  n = r * r  \<up>  (n + -1)"*)

	       \<^rule_thm>\<open>realpow_eq_oneI\<close>,

	       (*"1  \<up>  n = 1"*)

	       \<^rule_eval>\<open>plus\<close> (**)(eval_binop "#add_")

	       ],

      scr = Rule.Empty_Prog

      });

(*.contains absolute minimum of thms for context in norm_Rational.*)

val rat_mult_divide = prep_rls'(

  Rule_Def.Repeat {id = "rat_mult_divide", preconds = [], 

      rew_ord = ("dummy_ord", Rewrite_Ord.dummy_ord), 

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

      rules = [\<^rule_thm>\<open>rat_mult\<close>,

	       (*(1)"?a / ?b * (?c / ?d) = ?a * ?c / (?b * ?d)"*)

	       \<^rule_thm>\<open>times_divide_eq_right\<close>,

	       (*(2)"?a * (?c / ?d) = ?a * ?c / ?d" must be [2],

	       otherwise inv.to a / b / c = ...*)

	       \<^rule_thm>\<open>times_divide_eq_left\<close>,

	       (*"?a / ?b * ?c = ?a * ?c / ?b" order weights x \<up> n too much

		     and does not commute a / b * c  \<up>  2 !*)

	       \<^rule_thm>\<open>divide_divide_eq_right\<close>,

	       (*"?x / (?y / ?z) = ?x * ?z / ?y"*)

	       \<^rule_thm>\<open>divide_divide_eq_left\<close>,

	       (*"?x / ?y / ?z = ?x / (?y * ?z)"*)

	       \<^rule_eval>\<open>divide\<close> (Prog_Expr.eval_cancel "#divide_e")

	       ],

      scr = Rule.Empty_Prog

      });

(*.contains absolute minimum of thms for context in norm_Rational.*)

val reduce_0_1_2 = prep_rls'(

  Rule_Def.Repeat{id = "reduce_0_1_2", preconds = [], rew_ord = ("dummy_ord", Rewrite_Ord.dummy_ord),

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

      rules = [(*\<^rule_thm>\<open>divide_1\<close>,

		 "?x / 1 = ?x" unnecess.for normalform*)

	       \<^rule_thm>\<open>mult_1_left\<close>,                 

	       (*"1 * z = z"*)

	       (*\<^rule_thm>\<open>real_mult_minus1\<close>,

	       "-1 * z = - z"*)

	       (*\<^rule_thm>\<open>real_minus_mult_cancel\<close>,

	       "- ?x * - ?y = ?x * ?y"*)

	       \<^rule_thm>\<open>mult_zero_left\<close>,        

	       (*"0 * z = 0"*)

	       \<^rule_thm>\<open>add_0_left\<close>,

	       (*"0 + z = z"*)

	       (*\<^rule_thm>\<open>right_minus\<close>,

	       "?z + - ?z = 0"*)

	       \<^rule_thm_sym>\<open>real_mult_2\<close>,	

	       (*"z1 + z1 = 2 * z1"*)

	       \<^rule_thm>\<open>real_mult_2_assoc\<close>,

	       (*"z1 + (z1 + k) = 2 * z1 + k"*)

	       \<^rule_thm>\<open>division_ring_divide_zero\<close>

	       (*"0 / ?x = 0"*)

	       ], scr = Rule.Empty_Prog});

(*erls for calculate_Rational; 

  make local with FIXX@ME result:term *term list WN0609???SKMG*)

val norm_rat_erls = prep_rls'(

  Rule_Def.Repeat {id = "norm_rat_erls", preconds = [], rew_ord = ("dummy_ord",Rewrite_Ord.dummy_ord), 

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

      rules = [\<^rule_eval>\<open>Prog_Expr.is_const\<close> (Prog_Expr.eval_const "#is_const_")

	       ], scr = Rule.Empty_Prog});

(* consists of rls containing the absolute minimum of thms *)

(*040209: this version has been used by RL for his equations,

which is now replaced by MGs version "norm_Rational" below *)

val norm_Rational_min = prep_rls'(

  Rule_Def.Repeat {id = "norm_Rational_min", preconds = [], rew_ord = ("dummy_ord",Rewrite_Ord.dummy_ord), 

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

      rules = [(*sequence given by operator precedence*)

	       Rule.Rls_ discard_minus,

	       Rule.Rls_ powers,

	       Rule.Rls_ rat_mult_divide,

	       Rule.Rls_ expand,

	       Rule.Rls_ reduce_0_1_2,

	       Rule.Rls_ order_add_mult,

	       Rule.Rls_ collect_numerals,

	       Rule.Rls_ add_fractions_p,

	       Rule.Rls_ cancel_p

	       ],

      scr = Rule.Empty_Prog});

val norm_Rational_parenthesized = prep_rls'(

  Rule_Set.Sequence {id = "norm_Rational_parenthesized", preconds = []:term list, 

       rew_ord = ("dummy_ord", Rewrite_Ord.dummy_ord),

      erls = Atools_erls, srls = Rule_Set.Empty,

      calc = [], errpatts = [],

      rules = [Rule.Rls_  norm_Rational_min,

	       Rule.Rls_ discard_parentheses

	       ],

      scr = Rule.Empty_Prog});      

(*WN030318???SK: simplifies all but cancel and common_nominator*)

val simplify_rational = 

    Rule_Set.merge "simplify_rational" expand_binoms

    (Rule_Set.append_rules "divide" calculate_Rational

		[\<^rule_thm>\<open>div_by_1\<close>,

		 (*"?x / 1 = ?x"*)

		 \<^rule_thm>\<open>rat_mult\<close>,

		 (*(1)"?a / ?b * (?c / ?d) = ?a * ?c / (?b * ?d)"*)

		 \<^rule_thm>\<open>times_divide_eq_right\<close>,

		 (*(2)"?a * (?c / ?d) = ?a * ?c / ?d" must be [2],

		 otherwise inv.to a / b / c = ...*)

		 \<^rule_thm>\<open>times_divide_eq_left\<close>,

		 (*"?a / ?b * ?c = ?a * ?c / ?b"*)

		 \<^rule_thm>\<open>add_minus\<close>,

		 (*"?a + ?b - ?b = ?a"*)

		 \<^rule_thm>\<open>add_minus1\<close>,

		 (*"?a - ?b + ?b = ?a"*)

		 \<^rule_thm>\<open>divide_minus1\<close>

		 (*"?x / -1 = - ?x"*)

		 ]);

\<close>

ML \<open>

val add_fractions_p_rls = prep_rls'(

  Rule_Def.Repeat {id = "add_fractions_p_rls", preconds = [], rew_ord = ("dummy_ord", Rewrite_Ord.dummy_ord), 

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

	  rules = [Rule.Rls_ add_fractions_p], 

	  scr = Rule.Empty_Prog});

(* "Rule_Def.Repeat" causes repeated application of cancel_p to one and the same term *)

val cancel_p_rls = prep_rls'(

  Rule_Def.Repeat 

    {id = "cancel_p_rls", preconds = [], rew_ord = ("dummy_ord", Rewrite_Ord.dummy_ord), 

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

    rules = [Rule.Rls_ cancel_p], 

	  scr = Rule.Empty_Prog});

(*. makes 'normal' fractions; 'is_polyexp' inhibits double fractions;

    used in initial part norm_Rational_mg, see example DA-M02-main.p.60.*)

val rat_mult_poly = prep_rls'(

  Rule_Def.Repeat {id = "rat_mult_poly", preconds = [], rew_ord = ("dummy_ord", Rewrite_Ord.dummy_ord), 

	  erls = Rule_Set.append_rules "Rule_Set.empty-is_polyexp" Rule_Set.empty

      [\<^rule_eval>\<open>is_polyexp\<close> (eval_is_polyexp "")],

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

	  rules = 

	    [\<^rule_thm>\<open>rat_mult_poly_l\<close>,

	    (*"?c is_polyexp ==> ?c * (?a / ?b) = ?c * ?a / ?b"*)

	    \<^rule_thm>\<open>rat_mult_poly_r\<close>

	    (*"?c is_polyexp ==> ?a / ?b * ?c = ?a * ?c / ?b"*) ], 

	  scr = Rule.Empty_Prog});

(*. makes 'normal' fractions; 'is_polyexp' inhibits double fractions;

    used in looping part norm_Rational_rls, see example DA-M02-main.p.60 

    .. WHERE THE LATTER DOES ALWAYS WORK, BECAUSE erls = Rule_Set.empty, 

    I.E. THE RESPECTIVE ASSUMPTION IS STORED AND Rule.Thm APPLIED; WN051028 

    ... WN0609???MG.*)

val rat_mult_div_pow = prep_rls'(

  Rule_Def.Repeat {id = "rat_mult_div_pow", preconds = [], rew_ord = ("dummy_ord",Rewrite_Ord.dummy_ord), 

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

    rules = [\<^rule_thm>\<open>rat_mult\<close>,

      (*"?a / ?b * (?c / ?d) = ?a * ?c / (?b * ?d)"*)

      \<^rule_thm>\<open>rat_mult_poly_l\<close>,

      (*"?c is_polyexp ==> ?c * (?a / ?b) = ?c * ?a / ?b"*)

      \<^rule_thm>\<open>rat_mult_poly_r\<close>,

      (*"?c is_polyexp ==> ?a / ?b * ?c = ?a * ?c / ?b"*)

      \<^rule_thm>\<open>real_divide_divide1_mg\<close>,

      (*"y ~= 0 ==> (u / v) / (y / z) = (u * z) / (y * v)"*)

      \<^rule_thm>\<open>divide_divide_eq_right\<close>,

      (*"?x / (?y / ?z) = ?x * ?z / ?y"*)

      \<^rule_thm>\<open>divide_divide_eq_left\<close>,

      (*"?x / ?y / ?z = ?x / (?y * ?z)"*)

      \<^rule_eval>\<open>divide\<close> (Prog_Expr.eval_cancel "#divide_e"),

      \<^rule_thm>\<open>rat_power\<close>

      (*"(?a / ?b)  \<up>  ?n = ?a  \<up>  ?n / ?b  \<up>  ?n"*)

      ],

    scr = Rule.Empty_Prog});

val rat_reduce_1 = prep_rls'(

  Rule_Def.Repeat {id = "rat_reduce_1", preconds = [], rew_ord = ("dummy_ord", Rewrite_Ord.dummy_ord), 

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

    rules = 

      [\<^rule_thm>\<open>div_by_1\<close>,

      (*"?x / 1 = ?x"*)

      \<^rule_thm>\<open>mult_1_left\<close>           

      (*"1 * z = z"*)

      ],

    scr = Rule.Empty_Prog});

(* looping part of norm_Rational *)

val norm_Rational_rls = prep_rls' (

  Rule_Def.Repeat {id = "norm_Rational_rls", preconds = [], rew_ord = ("dummy_ord",Rewrite_Ord.dummy_ord), 

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

    rules = [Rule.Rls_ add_fractions_p_rls,

      Rule.Rls_ rat_mult_div_pow,

      Rule.Rls_ make_rat_poly_with_parentheses,

      Rule.Rls_ cancel_p_rls,

      Rule.Rls_ rat_reduce_1

      ],

    scr = Rule.Empty_Prog});

val norm_Rational = prep_rls' (

  Rule_Set.Sequence 

    {id = "norm_Rational", preconds = [], rew_ord = ("dummy_ord", Rewrite_Ord.dummy_ord), 

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

    rules = [Rule.Rls_ discard_minus,

      Rule.Rls_ rat_mult_poly,             (* removes double fractions like a/b/c *)

      Rule.Rls_ make_rat_poly_with_parentheses,

      Rule.Rls_ cancel_p_rls,

      Rule.Rls_ norm_Rational_rls,         (* the main rls, looping (#) *)

      Rule.Rls_ discard_parentheses1       (* mult only *)

      ],

    scr = Rule.Empty_Prog});

\<close>

rule_set_knowledge

  calculate_Rational = calculate_Rational and

  calc_rat_erls = calc_rat_erls and

  rational_erls = rational_erls and

  cancel_p = cancel_p and

  add_fractions_p = add_fractions_p and

  add_fractions_p_rls = add_fractions_p_rls and

  powers_erls = powers_erls and

  powers = powers and

  rat_mult_divide = rat_mult_divide and

  reduce_0_1_2 = reduce_0_1_2 and

  rat_reduce_1 = rat_reduce_1 and

  norm_rat_erls = norm_rat_erls and

  norm_Rational = norm_Rational and

  norm_Rational_rls = norm_Rational_rls and

  norm_Rational_min = norm_Rational_min and

  norm_Rational_parenthesized = norm_Rational_parenthesized and

  rat_mult_poly = rat_mult_poly and

  rat_mult_div_pow = rat_mult_div_pow and

  cancel_p_rls = cancel_p_rls

section \<open>A problem for simplification of rationals\<close>

problem pbl_simp_rat : "rational/simplification" =

  \<open>Rule_Set.append_rules "empty" Rule_Set.empty [(*for preds in where_*)]\<close>

  Method: "simplification/of_rationals"

  CAS: "Simplify t_t"

  Given: "Term t_t"

  Where: "t_t is_ratpolyexp"

  Find: "normalform n_n"

section \<open>A methods for simplification of rationals\<close>

(*WN061025 this methods script is copied from (auto-generated) script

  of norm_Rational in order to ease repair on inform*)

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

  where

"simplify term = (

  (Try (Rewrite_Set ''discard_minus'') #>

   Try (Rewrite_Set ''rat_mult_poly'') #>

   Try (Rewrite_Set ''make_rat_poly_with_parentheses'') #>

   Try (Rewrite_Set ''cancel_p_rls'') #>

   (Repeat (

     Try (Rewrite_Set ''add_fractions_p_rls'') #>

     Try (Rewrite_Set ''rat_mult_div_pow'') #>

     Try (Rewrite_Set ''make_rat_poly_with_parentheses'') #>

     Try (Rewrite_Set ''cancel_p_rls'') #>

     Try (Rewrite_Set ''rat_reduce_1''))) #>

   Try (Rewrite_Set ''discard_parentheses1''))

   term)"

method met_simp_rat : "simplification/of_rationals" =

  \<open>{rew_ord'="tless_true", rls' = Rule_Set.empty, calc = [], srls = Rule_Set.empty, 

    prls = Rule_Set.append_rules "simplification_of_rationals_prls" Rule_Set.empty 

      [(*for preds in where_*) \<^rule_eval>\<open>is_ratpolyexp\<close> (eval_is_ratpolyexp "")],

    crls = Rule_Set.empty, errpats = [], nrls = norm_Rational_rls}\<close>

  Program: simplify.simps

  Given: "Term t_t"

  Where: "t_t is_ratpolyexp"

  Find: "normalform n_n"

ML \<open>

\<close> ML \<open>

\<close>

end