(* Title:  KEStore/rule-set.sml

   Author: Walther Neuper

   (c) due to copyright terms

In ISAC a Rule_Set serves rewriting. KEStore holds all rule-sets for ubiquitous access.

*)

signature RULE_SET =

sig

  datatype rls = datatype Rule_Def.rls

  eqtype rls'

  type calc = Rule_Def.calc                                                    (*..from Rule_Def*)

  val e_rls: rls

  type rrlsstate = term * term * Rule_Def.rule list list * (Rule_Def.rule * (term * term list)) list

  val e_rrlsstate: rrlsstate

  val e_rrls: rls

  type rlss_elem

  val append_rls: string -> rls -> Rule_Def.rule list -> rls

  val rep_rls: rls -> {calc: calc list, erls: rls, errpats: Rule_Def.errpatID list, id: string,

    preconds: term list, rew_ord: Rule_Def.rew_ord, rules: Rule_Def.rule list, scr: Rule_Def.program, srls: rls}

  val rls2str: Rule_Def.rls -> string

  val id_rls: Rule_Def.rls -> string

  val id_rule: Rule_Def.rule -> string

  val eq_rule: Rule_Def.rule * Rule_Def.rule -> bool

  val merge_rls: string -> rls -> rls -> rls

  val merge_rlss: rlss_elem list * rlss_elem list -> rlss_elem list

  val remove_rls: string -> rls ->  Rule_Def.rule list -> rls

  val rule2str: Rule_Def.rule -> string

  val rule2str': Rule_Def.rule -> string

  eqtype prog_calcID

  type cal

  type calc_elem

  val calc_eq: calc_elem * calc_elem -> bool

  val e_evalfn: Rule_Def.eval_fn

  val get_rules: rls -> Rule_Def.rule list

  val rls_eq: (''a * ('b * 'c)) * (''a * ('d * 'e)) -> bool

(* ---- for tests only: shifted from below to remove the Warning "unused" at fun.def. --------- *)

  (*NONE*)

(*/-------------------------------------------------------- ! aktivate for Test_Isac BEGIN ---\* )

  (*NONE*)

( *\--- ! aktivate for Test_Isac END ----------------------------------------------------------/*)

end

(**)

structure Rule_Set(**): RULE_SET(**) =

struct

(**)

datatype rls = datatype Rule_Def.rls

type rls' = string

type calc = Rule_Def.calc

type subst = (term * term) list;

fun dummy_ord (_: subst) (_: term, _: term) = true;

val e_rls =

  Rls {id = "e_rls", preconds = [], rew_ord = ("dummy_ord", dummy_ord), erls = Erls,

    srls = Erls, calc = [], rules = [], errpatts = [], scr = Rule_Def.EmptyScr}: rls;

(*/--------------------------------------\*)

type rrlsstate =  (* state for reverse rewriting, comments see type rule and scr | Rfuns *)

  (term * term * Rule_Def.rule list list * (Rule_Def.rule * (term * term list)) list);

val e_rrlsstate = (Rule.e_term, Rule.e_term, [[Rule_Def.Erule]], [(Rule_Def.Erule, (Rule.e_term, []))]) : rrlsstate;

(*\--------------------------------------/*)

local

    fun ii (_: term) = e_rrlsstate;

    fun no (_: term) = SOME (Rule.e_term, [Rule.e_term]);

    fun lo (_: Rule_Def.rule list list) (_: term) (_: Rule_Def.rule) = [(Rule_Def.Erule, (Rule.e_term, [Rule.e_term]))];

    fun ne (_: Rule_Def.rule list list) (_: term) = SOME Rule_Def.Erule;

    fun fo (_: Rule_Def.rule list list) (_: term) (_: term) = [(Rule_Def.Erule, (Rule.e_term, [Rule.e_term]))];

in

val e_rfuns = Rule_Def.Rfuns {init_state = ii, normal_form = no, locate_rule = lo,

		  next_rule = ne, attach_form = fo};

end;

val e_rrls =

  Rrls {id = "e_rrls", prepat = [], rew_ord = ("dummy_ord", dummy_ord), erls = Erls,

    calc = [], errpatts = [], scr = e_rfuns}:rls;

fun rep_rls Erls = rep_rls e_rls

  | rep_rls (Rls {id, preconds, rew_ord, erls, srls, calc, errpatts, rules, scr}) =

    {id = id, preconds = preconds, rew_ord = rew_ord, erls = erls, srls = srls, errpats = errpatts,

      calc = calc, rules = rules, scr = scr}

  | rep_rls (Seq {id, preconds, rew_ord, erls, srls, calc, errpatts, rules, scr}) =

    {id = id, preconds = preconds, rew_ord = rew_ord, erls = erls, srls = srls, errpats = errpatts,

      calc = calc, rules = rules, scr = scr}

  | rep_rls (Rrls _)  = rep_rls e_rls

fun append_rls id Erls _ = raise ERROR ("append_rls: with \"" ^ id ^ "\" not for Erls")

  | append_rls id (Rls {id = _, preconds = pc, rew_ord = ro, erls = er, srls = sr, calc = ca,

			rules = rs, errpatts = errpatts, scr = sc}) r =

    Rls {id = id, preconds = pc, rew_ord = ro, erls = er, srls = sr, calc = ca,

      rules = rs @ r, errpatts = errpatts, scr = sc}

  | append_rls id (Seq {id = _, preconds = pc, rew_ord = ro, erls = er, srls = sr, calc = ca,

			rules = rs, errpatts = errpatts, scr = sc}) r =

    Seq {id = id, preconds = pc, rew_ord = ro, erls = er, srls = sr, calc = ca,

      rules = rs @ r, errpatts = errpatts, scr = sc}

  | append_rls id (Rrls _) _ = raise ERROR ("append_rls: not for reverse-rewrite-rule-set " ^ id);

fun id_rls Erls = "e_rls" (*WN060714 quick and dirty: recursive defs! TODO "Erls"*)

  | id_rls (Rule_Def.Rls {id, ...}) = id

  | id_rls (Rule_Def.Seq {id, ...}) = id

  | id_rls (Rule_Def.Rrls {id, ...}) = id;

val rls2str = id_rls;

fun id_rule (Rule_Def.Thm (id, _)) = id

  | id_rule (Rule_Def.Num_Calc (id, _)) = id

  | id_rule (Rule_Def.Cal1 (id, _)) = id

  | id_rule (Rule_Def.Rls_ rls) = id_rls rls

  | id_rule Rule_Def.Erule = "Erule";

fun eq_rule (Rule_Def.Thm (thm1, _), Rule_Def.Thm (thm2, _)) = thm1 = thm2

  | eq_rule (Rule_Def.Num_Calc (id1, _), Rule_Def.Num_Calc (id2, _)) = id1 = id2

  | eq_rule (Rule_Def.Rls_ rls1, Rule_Def.Rls_ rls2) = id_rls rls1 = id_rls rls2

  | eq_rule _ = false;

fun rule2str Rule_Def.Erule = "Erule"

  | rule2str (Rule_Def.Thm (str, thm)) = "Thm (\""^str^"\"," ^ Rule.string_of_thmI thm ^")"

  | rule2str (Rule_Def.Num_Calc (str, _)) = "Num_Calc (\""^str^"\",fn)"

  | rule2str (Rule_Def.Cal1 (str, _)) = "Cal1 (\""^str^"\",fn)"

  | rule2str (Rule_Def.Rls_ rls) = "Rls_ (\""^id_rls rls^"\")";

fun rule2str' Rule_Def.Erule = "Erule"

  | rule2str' (Rule_Def.Thm (str, _)) = "Thm (\""^str^"\",\"\")"

  | rule2str' (Rule_Def.Num_Calc (str, _)) = "Num_Calc (\""^str^"\",fn)"

  | rule2str' (Rule_Def.Cal1 (str, _)) = "Cal1 (\""^str^"\",fn)"

  | rule2str' (Rule_Def.Rls_ rls) = "Rls_ (\""^id_rls rls^"\")";

fun merge_ids rls1 rls2 =

  let 

    val id1 = (#id o rep_rls) rls1

    val id2 = (#id o rep_rls) rls2

  in

    if id1 = id2 then id1 else "merged_" ^ id1 ^ "_" ^ id2

  end

(* op in isa-term "Const(op,_)" *)

type cal = Rule_Def.calID * Rule_Def.eval_fn;

type prog_calcID = string;

type calc_elem =  (* fun calculate_ fetches the evaluation-function via this list *)

  prog_calcID *   (* a simple identifier used in programs                    *)

  (Rule_Def.calID *        (* a long identifier used in Const                         *)

    Rule_Def.eval_fn)      (* an ML function                                          *)

fun calc_eq ((pi1, (ci1, _)), (pi2, (ci2, _))) =

  if pi1 = pi2

  then if ci1 = ci2 then true else error ("calc_eq: " ^ ci1 ^ " <> " ^ ci2)

  else false

fun e_evalfn (_ : 'a) (_ : term) (_ : theory) = NONE : (string * term) option;

fun merge_rls _ Erls rls = rls

  | merge_rls _ rls Erls = rls

  | merge_rls _ (Rrls x) _ = Rrls x (* required for merging Theory_Data *)

  | merge_rls _ _ (Rrls x) = Rrls x

  | merge_rls id

	  (Rls {preconds = pc1, rew_ord = ro1, erls = er1, srls = sr1, calc = ca1,

	    rules = rs1, errpatts = eps1, scr = sc1, ...})

	  (Rls {preconds = pc2, erls = er2, srls = sr2, calc = ca2,

	    rules = rs2, errpatts = eps2, ...})

    =

	  Rls {id = id, rew_ord = ro1, scr = sc1,

	    preconds = union (op =) pc1 pc2,	    

	    erls = merge_rls (merge_ids er1 er2) er1 er2,

	    srls = merge_rls (merge_ids sr1 sr2) sr1 sr2,

	    calc = union calc_eq ca1 ca2,

		  rules = union eq_rule rs1 rs2,

      errpatts = union (op =) eps1 eps2}

  | merge_rls id

	  (Seq {preconds = pc1, rew_ord = ro1, erls = er1, srls = sr1, calc = ca1,

	    rules = rs1, errpatts = eps1, scr = sc1, ...})

	  (Seq {preconds = pc2, erls = er2, srls = sr2, calc = ca2,

	    rules = rs2, errpatts = eps2, ...})

    =

	  Seq {id = id, rew_ord = ro1, scr = sc1,

	    preconds = union (op =) pc1 pc2,	    

	    erls = merge_rls (merge_ids er1 er2) er1 er2,

	    srls = merge_rls (merge_ids sr1 sr2) sr1 sr2,

	    calc = union calc_eq ca1 ca2,

		  rules = union eq_rule rs1 rs2,

      errpatts = union (op =) eps1 eps2}

  | merge_rls id _ _ = error ("merge_rls: \"" ^ id ^ 

    "\"; not for reverse-rewrite-rule-sets and not for mixed Rls -- Seq");

(* datastructure for KEStore_Elems, intermediate for thehier *)

type rlss_elem = 

  (rls' *     (* identifier unique within Isac *)

  (Rule.theory' *  (* just for assignment in thehier, not appropriate for parsing etc *)

    Rule_Def.rls))     (* ((#id o rep_rls) rls) = rls'   by coding discipline *)

fun rls_eq ((id1, (_, _)), (id2, (_, _))) = id1 = id2

fun insert_merge_rls (re as (id, (thyID, r1)) : rlss_elem) ys = 

    case get_index (fn y => if curry rls_eq re y then SOME y else NONE) ys of

      NONE => re :: ys

    | SOME (i, (_, (_, r2))) => 

      let

        val r12 = merge_rls id r1 r2

      in list_update ys i (id, (thyID, r12)) end

fun merge_rlss (s1, s2) = fold insert_merge_rls s1 s2;

(* used only for one hack TODO remove *)

fun remove_rls id (Rls {id = _, preconds = pc, rew_ord = ro, erls = er, srls = sr, calc = ca,

		  rules = rs, errpatts = eps, scr = sc}) r =

    Rls {id = id, preconds = pc, rew_ord = ro, erls = er, srls = sr, calc = ca,

	    rules = gen_rems eq_rule (rs, r),

	    errpatts = eps,

	    scr = sc}

  | remove_rls id (Seq {id = _, preconds = pc, rew_ord = ro, erls = er, srls = sr, calc = ca,

		  rules = rs, errpatts = eps, scr = sc}) r =

    Seq {id = id, preconds = pc, rew_ord = ro, erls = er, srls = sr, calc = ca,

	    rules = gen_rems eq_rule (rs, r),

	    errpatts = eps,

	    scr = sc}

  | remove_rls id (Rrls _) _ = raise ERROR ("remove_rls: not for reverse-rewrite-rule-set "^id)

  | remove_rls _ rls _ = raise ERROR ("remove_rls called with " ^ rls2str rls);

fun get_rules Erls = []

  | get_rules (Rls {rules, ...}) = rules

  | get_rules (Seq {rules, ...}) = rules

  | get_rules (Rrls _) = [];

(**)end(**)