theory Base_Tools

  imports Interpret.Interpret

(** )"../BridgeJEdit/BridgeJEdit"                    ( *activate after devel.of BridgeJEdit*)

(**) "../BridgeLibisabelle/BridgeLibisabelle"           (*remove after devel.of BridgeJEdit*)

                      (*  ^^^ for KEStore_Elems.add_thes *)

begin

subsection \<open>theorems for Base_Tools\<close>

lemma real_unari_minus:   "Not (a is_num) ==> - a = (-1) * (a::real)" by auto

(*lemma real_unari_minus:   "- a = (-1) * (a::real)" by auto LOOPS WITH NUMERALS*)

(*Semiring_Normalization.comm_ring_1_class.ring_normalization_rules(1)*)

(* should be in Rational.thy, but needed for asms in e.g. d2_pqformula1 in PolyEq, RootEq... *)

lemma radd_left_cancel_le: "((k::real) + m \<le> k + n) = (m \<le> n)" by auto

(*Groups.ordered_ab_semigroup_add_imp_le_class.add_le_cancel_left*)

thm "Fields.linordered_field_class.mult_imp_le_div_pos" (*0 < ?y \<Longrightarrow> ?z * ?y \<le> ?x \<Longrightarrow> ?z \<le> ?x / ?y*)

axiomatization where (*for evaluating the assumptions of conditional rules*)

  (* should be in Rational.thy, but needed for asms in e.g. d2_pqformula1 in PolyEq, RootEq... *)

  rat_leq1: "0 \<noteq> b \<Longrightarrow> 0 \<noteq> d \<Longrightarrow> (a / b \<le> c / d) = (a * d \<le> b * c)"(*Quickcheck found a counterexample*) and

  rat_leq2:	          "0 \<noteq> d \<Longrightarrow> (a     \<le> c / d) = (a * d \<le>     c)"(*Quickcheck found a counterexample*) and

  rat_leq3:	"0 \<noteq> b           \<Longrightarrow> (a / b \<le> c    ) = (a     \<le> b * c)"(*Quickcheck found a counterexample*)

subsection \<open>setup for ML-functions\<close>

text \<open>required by "eval_binop" below\<close>

calculation occurs_in = \<open>Prog_Expr.eval_occurs_in "#occurs_in_"\<close>

calculation some_occur_in = \<open>Prog_Expr.eval_some_occur_in "#some_occur_in_"\<close>

calculation is_atom = \<open>Prog_Expr.eval_is_atom "#is_atom_"\<close>

calculation is_even = \<open>Prog_Expr.eval_is_even "#is_even_"\<close>

calculation le (less) = \<open>Prog_Expr.eval_equ "#less_"\<close>

calculation leq (less_eq) = \<open>Prog_Expr.eval_equ "#less_equal_"\<close>

calculation ident = \<open>Prog_Expr.eval_ident "#ident_"\<close>

calculation equal (HOL.eq) = \<open>Prog_Expr.eval_equal "#equal_"\<close>

calculation PLUS (plus) = \<open>(**)eval_binop "#add_"\<close>

calculation MINUS (minus) = \<open>(**)eval_binop "#sub_"\<close>

calculation TIMES (times) = \<open>(**)eval_binop "#mult_"\<close>

calculation DIVIDE (divide) = \<open>Prog_Expr.eval_cancel "#divide_e"\<close>

calculation POWER (realpow) = \<open>(**)eval_binop "#power_"\<close>

calculation boollist2sum = \<open>Prog_Expr.eval_boollist2sum ""\<close>

subsection \<open>rewrite-order for rule-sets\<close>

ML \<open>

\<close> ML \<open>

local

  open Term;

in

  fun termlessI (_: subst) uv = LibraryC.termless uv;

  fun term_ordI (_: subst) uv = Term_Ord.term_ord uv;

end;

\<close> ML \<open>

(*TODO.WN0509 reduce ids: tless_true = e_rew_ord' = Rewrite_Ord.function_empty = Rewrite_Ord.function_empty*)

val tless_true = Rewrite_Ord.function_empty;

\<close> ML \<open>

\<close> 

setup \<open>KEStore_Elems.add_rew_ord [

  ("tless_true", tless_true),

	("Rewrite_Ord.id_empty", tless_true),

	("e_rew_ord'", tless_true),

	("dummy_ord", Rewrite_Ord.function_empty)]\<close>

subsection \<open>rule-sets\<close>

ML \<open>

\<close> ML \<open>

val Atools_erls = Rule_Set.append_rules "Atools_erls" Rule_Set.empty [

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

  \<^rule_thm>\<open>not_true\<close>, (*"(~ True) = False"*)

	\<^rule_thm>\<open>not_false\<close>, (*"(~ False) = True"*)

	\<^rule_thm>\<open>and_true\<close>, (*"(?a & True) = ?a"*)

	\<^rule_thm>\<open>and_false\<close>, (*"(?a & False) = False"*)

	\<^rule_thm>\<open>or_true\<close>, (*"(?a | True) = True"*)

	\<^rule_thm>\<open>or_false\<close>, (*"(?a | False) = ?a"*)

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

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

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

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

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

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

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

	\<^rule_eval>\<open>less_eq\<close> (Prog_Expr.eval_equ "#less_equal_"),

	\<^rule_eval>\<open>Prog_Expr.ident\<close> (Prog_Expr.eval_ident "#ident_"),

	\<^rule_eval>\<open>Prog_Expr.is_num\<close> (Prog_Expr.eval_is_num "#is_num_"),

	\<^rule_eval>\<open>Prog_Expr.occurs_in\<close> (Prog_Expr.eval_occurs_in ""),

	\<^rule_eval>\<open>Prog_Expr.matches\<close> (Prog_Expr.eval_matches "")];

\<close>

ML \<open>

val Atools_crls = Rule_Set.append_rules "Atools_crls" Rule_Set.empty [

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 	\<^rule_eval>\<open>less_eq\<close> (Prog_Expr.eval_equ "#less_equal_"),

 	\<^rule_eval>\<open>Prog_Expr.ident\<close> (Prog_Expr.eval_ident "#ident_"),

	\<^rule_eval>\<open>Prog_Expr.is_num\<close> (Prog_Expr.eval_is_num "#is_num_"),

 	\<^rule_eval>\<open>Prog_Expr.occurs_in\<close> (Prog_Expr.eval_occurs_in ""),

 	\<^rule_eval>\<open>Prog_Expr.matches\<close> (Prog_Expr.eval_matches "")];

\<close>

subsection \<open>ONCE AGAIN extend rule-set for evaluating pre-conditions and program-expressions\<close>

text \<open>requires "eval_binop" from above\<close>

ML \<open>

val prog_expr = Rule_Set.append_rules "prog_expr" prog_expr [

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

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

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

	\<^rule_eval>\<open>less_eq\<close> (Prog_Expr.eval_equ "#less_equal_"),

	\<^rule_eval>\<open>Prog_Expr.ident\<close> (Prog_Expr.eval_ident "#ident_"),

	\<^rule_eval>\<open>HOL.eq\<close> (Prog_Expr.eval_equal "#equal_"),(*atom <> atom -> False*)

	\<^rule_eval>\<open>Prog_Expr.Vars\<close> (Prog_Expr.eval_var "#Vars_"),

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

	\<^rule_thm>\<open>if_False\<close>];

val prog_expr = Auto_Prog.prep_rls @{theory} (Rule_Set.merge "list_erls"

	(Rule_Def.Repeat {id = "replaced", preconds = [], rew_ord = ("termlessI", termlessI),

    erls = Rule_Def.Repeat {id = "list_elrs", preconds = [], rew_ord = ("termlessI", termlessI), 

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

    rules = [

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

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

    scr = Rule.Empty_Prog},

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

    rules = [], scr = Rule.Empty_Prog})

  prog_expr);

\<close>

subsection \<open>setup for extended rule-set\<close>

rule_set_knowledge prog_expr = \<open>Auto_Prog.prep_rls @{theory} prog_expr\<close>

ML \<open>

\<close> ML \<open>

\<close> ML \<open>

\<close>

end