(* title:  ProgLang/Prog_Expr.thy

           functions for expressions (which do NOT contain Prog_Tac and Tactical, by definition))

   author: Walther Neuper, Aug.2019

   (c) copyright due to lincense terms.

*)

theory Prog_Expr

  imports Calculate ListC Program

begin

text \<open>Abstract:

  Specific constants are defined for pre-conditions of programs and for program-expressions.

  The constants are connected with ML functions for evaluation of respective expressions

  (all named eval_*), such that Isac's rewrite engine can handle it.

\<close>

subsection \<open>consts of functions in pre-conditions and program-expressions\<close>

consts

  lhs             :: "bool => real"           (*of an equality*)

  rhs             :: "bool => real"           (*of an equality*)

  Vars            :: "'a => real list"        (*get the variables of a term *)

  matches         :: "['a, 'a] => bool"

  matchsub        :: "['a, 'a] => bool"

  some_occur_in  :: "[real list, 'a] => bool" ("some'_of _ occur'_in _")

  occurs_in       :: "[real     , 'a] => bool" ("_ occurs'_in _")

  abs              :: "real => real"            ("(|| _ ||)")

  (* ~~~ FIXXXME Isabelle2002 has abs already !!!*)

  absset           :: "real set => real"        ("(||| _ |||)")

  is_atom         :: "real => bool"            ("_ is'_atom" 10)

  is_num         :: "real => bool"             ("_ is'_num" 10)

  is_even         :: "real => bool"            ("_ is'_even" 10)

  (* identity on term level*)

  ident            :: "['a, 'a] => bool"        ("(_ =!=/ _)" [51, 51] 50)

  argument_in     :: "real => real"            ("argument'_in _" 10)

  sameFunId        :: "[real, bool] => bool"    (* "same_funid _ _" 10

	                    WN0609 changed the id, because ".. _ _" inhibits currying *)

  filter_sameFunId:: "[real, bool list] => bool list" ("filter'_sameFunId _ _" 10)

  boollist2sum     :: "bool list => real"

  lastI            :: "'a list \<Rightarrow> 'a"

subsection \<open>ML code for functions in pre-conditions and program-expressions\<close>

ML \<open>

signature PROG_EXPR =

  sig

    val eval_lhs: 'a -> string -> term -> 'b -> (string * term) option

    val eval_matches: string -> string -> term -> Proof.context -> (string * term) option

    val matchsub: theory -> term -> term -> bool

    val eval_matchsub: string -> string -> term -> Proof.context -> (string * term) option

    val eval_rhs: 'a -> string -> term -> 'b -> (string * term) option

    val eval_var: string -> string -> term -> Proof.context -> (string * term) option

    val or2list: term -> term

    val occurs_in: term -> term -> bool

    val eval_occurs_in: 'a -> string -> term -> 'b -> (string * term) option

    val some_occur_in: term list -> term -> bool

    val eval_some_occur_in: 'a -> string -> term -> 'b -> (string * term) option

    val eval_is_atom: string -> string -> term -> 'a -> (string * term) option

    val eval_is_num: string -> string -> term -> 'a -> (string * term) option

    val even: int -> bool

    val eval_is_even: string -> string -> term -> 'a -> (string * term) option

    val eval_equ: string -> string -> term -> 'a -> (string * term) option

    val eval_ident: string -> string -> term -> Proof.context -> (string * term) option

    val eval_equal: string -> string -> term -> Proof.context -> (string * term) option

    val eval_cancel: string -> string -> term -> 'a -> (string * term) option

    val eval_argument_in: string -> string -> term -> 'a -> (string * term) option

    val same_funid: term -> term -> bool

    val eval_sameFunId: string -> string -> term -> 'a -> (string * term) option

    val eval_filter_sameFunId: string -> string -> term -> 'a -> (string * term) option

    val list2sum: term list -> term

    val eval_boollist2sum: string -> string -> term -> 'a -> (string * term) option

    val mk_thmid_f: string -> (int * int) * (int * int) -> (int * int) * (int * int) -> string

  end

(**)

structure Prog_Expr(**): PROG_EXPR(**) =

struct

(**)

(*+ for Or_to_List +*)

fun or2list (Const (\<^const_name>\<open>True\<close>,_)) = ((*tracing"### or2list True";*) UniversalList)

  | or2list (Const (\<^const_name>\<open>False\<close>,_)) = ((*tracing"### or2list False";*) EmptyList)

  | or2list (t as Const (\<^const_name>\<open>HOL.eq\<close>,_) $ _ $ _) = TermC.list2isalist HOLogic.boolT [t]

  | or2list ors =

    let

      fun get ls (Const (\<^const_name>\<open>disj\<close>,_) $ o1 $ o2) =

	        (case o2 of

	         	Const (\<^const_name>\<open>disj\<close>,_) $ _ $ _ => get (ls @ [o1]) o2

	        | _ => ls @ [o1, o2])

        | get _ t = raise TERM ("or2list: missing pattern in fun.def", [t])

    in (((TermC.list2isalist HOLogic.boolT) o (get [])) ors) end

(** evaluation on the meta-level **)

(*. evaluate the predicate matches (match on whole term only) .*)

(*("matches",("Prog_Expr.matches", eval_matches "#matches_")):calc*)

fun eval_matches (_:string) "Prog_Expr.matches" 

      (t as Const (\<^const_name>\<open>Prog_Expr.matches\<close>, _) $ pat $ tst) ctxt = 

    if TermC.matches (Proof_Context.theory_of ctxt) tst pat

    then 

      let

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

	    in SOME (UnparseC.term_in_ctxt ctxt prop, prop) end

    else 

      let 

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

	    in SOME (UnparseC.term_in_ctxt ctxt prop, prop) end

  | eval_matches _ _ _ _ = NONE; 

(*.does a pattern match some subterm ?.*)

fun matchsub thy t pat =  

  let

    fun matchs (t as Const _) = TermC.matches thy t pat

	      | matchs (t as Free _) = TermC.matches thy t pat

	      | matchs (t as Var _) = TermC.matches thy t pat

	      | matchs (Bound _) = false

	      | matchs (t as Abs (_, _, body)) = 

	          if TermC.matches thy t pat then true else TermC.matches thy body pat

	      | matchs (t as f1 $ f2) =

	          if TermC.matches thy t pat then true 

	            else if matchs f1 then true else matchs f2

  in matchs t end;

(*("matchsub",("Prog_Expr.matchsub", eval_matchsub "#matchsub_")):calc*)

fun eval_matchsub (_:string) "Prog_Expr.matchsub"

      (t as Const (\<^const_name>\<open>Prog_Expr.matchsub\<close>, _) $ pat $ tst) ctxt = 

    if matchsub (Proof_Context.theory_of ctxt) tst pat

    then 

      let val prop = HOLogic.Trueprop $ (TermC.mk_equality (t, @{term True}))

      in SOME (UnparseC.term_in_ctxt ctxt prop, prop) end

    else 

      let val prop = HOLogic.Trueprop $ (TermC.mk_equality (t, @{term False}))

      in SOME (UnparseC.term_in_ctxt ctxt prop, prop) end

  | eval_matchsub _ _ _ _ = NONE; 

(*get the variables in an isabelle-term*)

(*("Vars"    ,("Prog_Expr.Vars"    , eval_var "#Vars_")):calc*)

fun eval_var (thmid:string) "Prog_Expr.Vars" (t as (Const _ $ arg)) ctxt = 

    let 

      val t' = ((TermC.list2isalist HOLogic.realT) o TermC.vars) t;

      val thmId = thmid ^ UnparseC.term_in_ctxt ctxt arg;

    in SOME (thmId, HOLogic.Trueprop $ (TermC.mk_equality (t, t'))) end

  | eval_var _ _ _ _ = NONE;

(*("lhs"    ,("Prog_Expr.lhs"    , eval_lhs "")):calc*)

fun eval_lhs _ "Prog_Expr.lhs" (t as (Const (\<^const_name>\<open>lhs\<close>,_) $ (Const (\<^const_name>\<open>HOL.eq\<close>,_) $ l $ _))) _ = 

    SOME ((UnparseC.term t) ^ " = " ^ (UnparseC.term l),

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

  | eval_lhs _ _ _ _ = NONE;

fun rhs (Const (\<^const_name>\<open>HOL.eq\<close>,_) $ _ $ r) = r

  | rhs t = raise ERROR("rhs called with (" ^ UnparseC.term t ^ ")");

(*("rhs"    ,("Prog_Expr.rhs"    , eval_rhs "")):calc*)

fun eval_rhs _ "Prog_Expr.rhs" (t as (Const (\<^const_name>\<open>rhs\<close>,_) $ (Const (\<^const_name>\<open>HOL.eq\<close>,_) $ _ $ r))) _ = 

    SOME (UnparseC.term t ^ " = " ^ UnparseC.term r,

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

  | eval_rhs _ _ _ _ = NONE;

fun occurs_in v t = member op = (((map strip_thy) o TermC.ids2str) t) (Term.term_name v);

(*("occurs_in", ("Prog_Expr.occurs_in", Prog_Expr.eval_occurs_in ""))*)

fun eval_occurs_in _ "Prog_Expr.occurs_in" (p as (Const (\<^const_name>\<open>occurs_in\<close>, _) $ v $ t)) _ =

    ((*tracing("#>@ eval_occurs_in: v= "^(UnparseC.term v));

     tracing("#>@ eval_occurs_in: t= "^(UnparseC.term t));*)

     if occurs_in v t

    then SOME ((UnparseC.term p) ^ " = True",

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

    else SOME ((UnparseC.term p) ^ " = False",

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

  | eval_occurs_in _ _ _ _ = NONE;

(*some of the (bound) variables (eg. in an eqsys) "vs" occur in term "t"*)   

fun some_occur_in vs t = 

    let fun occurs_in' a b = occurs_in b a

    in foldl or_ (false, map (occurs_in' t) vs) end;

(*("some_occur_in", ("Prog_Expr.some_occur_in", 

			eval_some_occur_in "#eval_some_occur_in_"))*)

fun eval_some_occur_in _ "Prog_Expr.some_occur_in"

			  (p as (Const (\<^const_name>\<open>some_occur_in\<close>,_) $ vs $ t)) _ =

    if some_occur_in (TermC.isalist2list vs) t

    then SOME ((UnparseC.term p) ^ " = True",

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

    else SOME ((UnparseC.term p) ^ " = False",

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

  | eval_some_occur_in _ _ _ _ = NONE;

(*("is_atom",("Prog_Expr.is_atom", Prog_Expr.eval_is_atom "#is_atom_"))*)

fun eval_is_atom (thmid:string) "Prog_Expr.is_atom" (t as (Const _ $ arg)) _ = 

    if TermC.is_atom arg

    then SOME (TermC.mk_thmid thmid (TermC.string_of_atom arg) "", 

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

    else SOME (TermC.mk_thmid thmid (TermC.string_of_atom arg) "", 

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

  | eval_is_atom _ _ _ _ = NONE;

(*("is_num",("Prog_Expr.is_num", Prog_Expr.eval_is_num "#is_num_"))*)

fun eval_is_num (thmid:string) "Prog_Expr.is_num" (t as (Const _ $ arg)) _ = 

    if TermC.is_num arg

    then SOME (TermC.mk_thmid thmid (TermC.string_of_atom arg) "", 

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

    else SOME (TermC.mk_thmid thmid (TermC.string_of_atom arg) "", 

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

  | eval_is_num _ _ _ _ = NONE;

fun even i = (i div 2) * 2 = i;

(*("is_even",("Prog_Expr.is_even", eval_is_even "#is_even_"))*)

fun eval_is_even (thmid:string) "Prog_Expr.is_even" (t as (Const _ $ arg)) _ = 

    if TermC.is_num arg

    then

      let

        val i = arg |> HOLogic.dest_number |> snd

      in

	      if even i 

        then SOME (TermC.mk_thmid thmid (string_of_int i) "", 

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

	      else SOME (TermC.mk_thmid thmid "" "", 

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

      end

    else NONE

  | eval_is_even _ _ _ _ = NONE; 

(*. evaluate binary, associative, commutative operators: *,+,^ .*)

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

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

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

(* val (thmid,op_,t as(Const (op0,t0) $ Free (n1,t1) $ Free(n2,t2)),thy) =

       ("xxxxxx",op_,t,thy);

   *)

fun mk_thmid_f thmid ((v11, v12), (p11, p12)) ((v21, v22), (p21, p22)) = (* dropped *)

  thmid ^ "Float ((" ^ 

  (string_of_int v11)^", "^(string_of_int v12)^"), ("^

  (string_of_int p11)^", "^(string_of_int p12)^")) __ (("^

  (string_of_int v21)^", "^(string_of_int v22)^"), ("^

  (string_of_int p21)^", "^(string_of_int p22)^"))";

(*.evaluate < and <= for numerals.*)

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

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

fun eval_equ (thmid:string) (_(*op_*)) (t as (Const (op0, _)) $ t1 $ t2) _ =

    if TermC.is_num t1 andalso TermC.is_num t2 then

      let

        val n1 = t1 |> HOLogic.dest_number |> snd 

        val n2 = t2 |> HOLogic.dest_number |> snd 

      in

        if Eval.calc_equ (strip_thy op0) (n1, n2)

        then SOME (TermC.mk_thmid thmid (string_of_int n1) (string_of_int n2), 

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

        else SOME (TermC.mk_thmid thmid (string_of_int n1) (string_of_int n2),  

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

      end

    else NONE

  | eval_equ _ _ _ _ = NONE;

(*evaluate identity

> reflI;

val it = "(?t = ?t) = True"

> val t = str2term "x = 0";

> val NONE = rewrite_ thy Rewrite_Ord.function_empty Rule_Set.empty false reflI t;

> val t = str2term "1 = 0";

> val NONE = rewrite_ thy Rewrite_Ord.function_empty Rule_Set.empty false reflI t;

----------- thus needs Rule.Eval !

> val t = str2term "0 = 0";

> val SOME (t',_) = rewrite_ thy Rewrite_Ord.function_empty Rule_Set.empty false reflI t;

> UnparseC.term t';

val it = \<^const_name>\<open>True\<close>

val t = str2term "Not (x = 0)";

atomt t; UnparseC.term t;

*** -------------

*** Const ( Not)

*** . Const ( op =)

*** . . Free ( x, )

*** . . Free ( 0, )

val it = "x ~= 0" : string*)

(*.evaluate identity on the term-level, =!= ,i.e. without evaluation of 

  the arguments: thus special handling by 'fun eval_binop'*)

(*("ident"   ,("Prog_Expr.ident", Prog_Expr.eval_ident "#ident_")):calc*)

fun eval_ident (thmid:string) "Prog_Expr.ident" (t as 

	       (Const _(*op0, t0*) $ t1 $ t2 )) ctxt = 

  if t1 = t2

  then SOME (TermC.mk_thmid thmid 

	              ("(" ^ (UnparseC.term_in_ctxt ctxt t1) ^ ")")

	              ("(" ^ (UnparseC.term_in_ctxt ctxt t2) ^ ")"), 

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

  else SOME (TermC.mk_thmid thmid  

	              ("(" ^ (UnparseC.term_in_ctxt ctxt t1) ^ ")")

	              ("(" ^ (UnparseC.term_in_ctxt ctxt t2) ^ ")"),  

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

  | eval_ident _ _ _ _ = NONE;

(* TODO

> val t = str2term "x =!= 0";

> val SOME (str, t') = eval_ident "ident_" "b" t thy;

> UnparseC.term t';

val str = "ident_(x)_(0)" : string

val it = "(x =!= 0) = False" : string                                

> val t = str2term "1 =!= 0";

> val SOME (str, t') = eval_ident "ident_" "b" t thy;

> UnparseC.term t';

val str = "ident_(1)_(0)" : string 

val it = "(1 =!= 0) = False" : string                                       

> val t = str2term "0 =!= 0";

> val SOME (str, t') = eval_ident "ident_" "b" t thy;

> UnparseC.term t';

val str = "ident_(0)_(0)" : string

val it = "(0 =!= 0) = True" : string

*)

(* evaluate identity of terms, which stay ready for further evaluation;

  thus returns False only for atoms *)

(*("equal"   ,(\<^const_name>\<open>HOL.eq\<close>, Prog_Expr.eval_equal "#equal_")):calc*)

fun eval_equal (thmid : string) \<^const_name>\<open>HOL.eq\<close> (t as (Const _(*op0,t0*) $ t1 $ t2 )) ctxt = 

  if t1 = t2

  then

    SOME (TermC.mk_thmid thmid

      ("(" ^ UnparseC.term_in_ctxt ctxt t1 ^ ")") ("(" ^ UnparseC.term_in_ctxt ctxt t2 ^ ")"), 

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

  else

    (case (TermC.is_atom t1, TermC.is_atom t2) of

      (true, true) =>

        if TermC.variable_constant_pair (t1, t2)

        then NONE

        else SOME (TermC.mk_thmid thmid

          ("(" ^ UnparseC.term_in_ctxt ctxt t1 ^ ")") ("(" ^ UnparseC.term_in_ctxt ctxt t2 ^ ")"),

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

    | _ => NONE)                                              (* NOT is_atom t1,t2 --> rew_sub *)

  | eval_equal _ _ _ _ = NONE;                                                   (* error-exit *)

(*. evaluate HOL.divide .*)

(*("DIVIDE" ,("Rings.divide_class.divide"  , eval_cancel "#divide_e"))*)

fun eval_cancel thmid "Rings.divide_class.divide" (t as (Const _ $ t1 $ t2)) _ = 

    if TermC.is_num t1 andalso TermC.is_num t2 then

      let

        val (T, _) = HOLogic.dest_number t1;

        val (i1, i2) = (Eval.int_of_numeral t1, Eval.int_of_numeral t2);

        val res_int as (d, (i1', i2')) = Eval.cancel_int (i1, i2);

      in

        if abs d = 1 andalso (abs i1, abs i2) = (abs i1', abs i2') then NONE

        else

          let

            val res = TermC.mk_frac T res_int;

            val prop = HOLogic.Trueprop $ (HOLogic.mk_eq (t, res));

          in SOME (TermC.mk_thmid thmid (string_of_int i1) (string_of_int i2), prop) end

      end

    else NONE

  | eval_cancel _ _ _ _ = NONE;

(* get the argument from a function-definition *)

(*("argument_in" ,("Prog_Expr.argument_in", Prog_Expr.eval_argument_in "Prog_Expr.argument_in"))*)

fun eval_argument_in _ "Prog_Expr.argument_in" 

		 (t as (Const ("Prog_Expr.argument_in", _) $ (_(*f*) $ arg))) _ =

    if TermC.is_atom arg (*could be something to be simplified before*)

    then

      SOME (UnparseC.term t ^ " = " ^ UnparseC.term arg,

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

    else NONE

  | eval_argument_in _ _ _ _ = NONE;

(* check if the function-identifier of the first argument matches 

   the function-identifier of the lhs of the second argument *)

(*("sameFunId" ,("Prog_Expr.sameFunId", eval_same_funid "Prog_Expr.sameFunId"))*)

fun eval_sameFunId _ "Prog_Expr.sameFunId" 

		     (p as Const ("Prog_Expr.sameFunId",_) $  (f1 $ _) $ (Const (\<^const_name>\<open>HOL.eq\<close>, _) $ (f2 $ _) $ _)) _ =

    if f1 = f2 

    then SOME ((UnparseC.term p) ^ " = True",

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

    else SOME ((UnparseC.term p) ^ " = False",

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

| eval_sameFunId _ _ _ _ = NONE;

(*.from a list of fun-definitions "f x = ..." as 2nd argument

   filter the elements with the same fun-identfier in "f y"

   as the fst argument;

   this is, because Isabelles filter takes more than 1 sec.*)

fun same_funid f1 (Const (\<^const_name>\<open>HOL.eq\<close>, _) $ (f2 $ _) $ _) = f1 = f2

  | same_funid f1 t = raise ERROR ("same_funid called with t = ("

		  ^ UnparseC.term f1 ^ ") (" ^ UnparseC.term t ^ ")");

(*("filter_sameFunId" ,("Prog_Expr.filter_sameFunId",

		   eval_filter_sameFunId "Prog_Expr.filter_sameFunId"))*)

fun eval_filter_sameFunId _ "Prog_Expr.filter_sameFunId" 

		     (p as Const ("Prog_Expr.filter_sameFunId",_) $ 

			(fid $ _) $ fs) _ =

    let val fs' = ((TermC.list2isalist HOLogic.boolT) o 

		   (filter (same_funid fid))) (TermC.isalist2list fs)

    in SOME (UnparseC.term (TermC.mk_equality (p, fs')),

	       HOLogic.Trueprop $ (TermC.mk_equality (p, fs'))) end

| eval_filter_sameFunId _ _ _ _ = NONE;

(* make a list of terms to a sum *)

fun list2sum [] = raise ERROR ("list2sum called with []")

  | list2sum [s] = s

  | list2sum (s::ss) = 

    let

      fun sum su [s'] = Const (\<^const_name>\<open>plus\<close>,

           [HOLogic.realT,HOLogic.realT] ---> HOLogic.realT) $ su $ s'

    	  | sum su (s'::ss') = sum (Const (\<^const_name>\<open>plus\<close>,

           [HOLogic.realT,HOLogic.realT] ---> HOLogic.realT) $ su $ s') ss'

    	  | sum _ _ = raise ERROR "list2sum: pattern in fun.def is missing" 

    in sum s ss end;

(* make a list of equalities to the sum of the lhs *)

(*("boollist2sum"    ,("Prog_Expr.boollist2sum"    , eval_boollist2sum "")):calc*)

fun eval_boollist2sum _ "Prog_Expr.boollist2sum" 

		  (p as Const ("Prog_Expr.boollist2sum", _) $ (l as Const (\<^const_name>\<open>Cons\<close>, _) $ _ $ _)) _ =

    let

      val isal = TermC.isalist2list l

	    val lhss = map TermC.lhs isal

	    val sum = list2sum lhss

    in

      SOME ((UnparseC.term p) ^ " = " ^ (UnparseC.term sum),

	      HOLogic.Trueprop $ (TermC.mk_equality (p, sum)))

    end

  | eval_boollist2sum _ _ _ _ = NONE;

(**) end (*struct*)

\<close> text \<open>

open Prog_Expr

\<close> ML \<open>

\<close> ML \<open>

\<close>

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

ML \<open>

val prog_expr = Rule_Set.append_rules "prog_expr" prog_expr [\<^rule_eval>\<open>Prog_Expr.rhs\<close> (Prog_Expr.eval_rhs "")];

\<close> ML \<open>

\<close> ML \<open>

\<close>

subsection \<open>setup for rule-sets and ML-functions\<close>

rule_set_knowledge prog_expr = prog_expr

calculation lhs = \<open>Prog_Expr.eval_lhs ""\<close>

calculation rhs = \<open>Prog_Expr.eval_rhs ""\<close>

calculation Vars = \<open>Prog_Expr.eval_var "#Vars_"\<close>

calculation matches = \<open>Prog_Expr.eval_matches "#matches_"\<close>

calculation matchsub = \<open>Prog_Expr.eval_matchsub "#matchsub_"\<close>

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

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

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

calculation is_num = \<open>Prog_Expr.eval_is_num "#is_num_"\<close>

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

ML \<open>

\<close> ML \<open>

\<close> ML \<open>

\<close>

end