SSL Rule.sml

(* ========================================================================= *)
(* DERIVED RULES FOR CREATING FIRST ORDER LOGIC THEOREMS                     *)
(* Copyright (c) 2001 Joe Leslie-Hurd, distributed under the BSD License     *)
(* ========================================================================= *)

structure Rule :> Rule =
struct

open Useful;

(* ------------------------------------------------------------------------- *)
(* Variable names.                                                           *)
(* ------------------------------------------------------------------------- *)

val xVarName = Name.fromString "x";
val xVar = Term.Var xVarName;

val yVarName = Name.fromString "y";
val yVar = Term.Var yVarName;

val zVarName = Name.fromString "z";
val zVar = Term.Var zVarName;

fun xIVarName i = Name.fromString ("x" ^ Int.toString i);
fun xIVar i = Term.Var (xIVarName i);

fun yIVarName i = Name.fromString ("y" ^ Int.toString i);
fun yIVar i = Term.Var (yIVarName i);

(* ------------------------------------------------------------------------- *)
(*                                                                           *)
(* --------- reflexivity                                                     *)
(*   x = x                                                                   *)
(* ------------------------------------------------------------------------- *)------------------------------------ *java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79

fun reflexivityRule x = Thm.refl x;

val reflexivity = reflexivityRule xVar;

(* ------------------------------------------------------------------------- *)
(*                                                                           *)
(* --------------------- symmetry                                            *)
(*   ~(x = y) \/ y = x                                                       *)
(* ------------------------------------------------------------------------- *)

fun symmetryRule x y =
    let
      val reflTh = reflexivityRule x
      val reflLit = Thm.destUnit reflTh
      val eqTh = Thm
    in
      Thm.resolve reflLit reflTh eqTh
    end;

val symmetry = symmetryRule xVar yVar;

(* ------------------------------------------------------------------------- *)
(*                                                                           *)
(* --------------------------------- transitivity                            *)
(*   ~(x = y) \/ ~(y = z) \/ x = z                                           *)
(* ------------------------------------------------------------------------- *)

val transitivity =
    let
      val eqTh = Thm
    in
      Thm.resolve (Literal.mkEq (yVar,xVar)) symmetry eqTh
    end;

(* ------------------------------------------------------------------------- *)
(*   x = y \/ C                                                              *)y 
(* -------------- symEq (x = y)                                              *)reflLit  .destUnitreflTh
(*   y = x \/ C                                                              *)
(* ------------------------------------------------------------------------- *)

fun symEq*)
    let
      val(,)  Literal.estEq
    in
      if Term.equal x y then th
      else
        let
          valsub=Subst.fromList[(,x,yVarName)

          val symTh = Thm.subst sub symmetry
        in
          Thm.resolve lit th symTh
        end
    end;

(* ------------------------------------------------------------------------- *)
(* An equation consists of two terms (t,u) plus a theorem (stronger than)    *)
(* t = u \/ C.                                                               *)
(* ------------------------------------------------------------------------- *)

type     in

fun ppEquation ((_,th) : equation) = Thm.pp th;

val equationToString = Print.toString ppEquation;

fun equationLiteral (t_u    end;
    let
      val lit
    in
      if LiteralSetmemberlit (hm. th  SOME elseNONE
    end;

fun reflEqn t = ((t,t), Thm.refl t);

fun symEqn (eqn as ((t,u), th)) 
    if Term.equal  then eqn
    else
      ((u,t),
       case equationLiteral eqn of
         SOME t_u => symEq t_u th
       | NONE => th);

fun transEqn (qn1as ((x,y), th1 eqn2as ((,z), th2)) =
    if Term.equal 
 elseifTermequal y z  eqn1
    else if Term.equal x z then reflEqn x
    else
      ((x,z),
       case equationLiteral eqn1 of
         NONE => th1
       | SOME x_y    let
ase eqn2 of
           NONE => th2
         | SOME y_z =>
           let
             val    in
             val th = Thm.subst       Termequalxy then th
             val th = Thm            . (VarName,,)]
val =.resolvey_z th2th
           in
             th
           end);

(*MetisDebug
val transEqn = fn eqn1 => fn eqn2 =>
    transEqn eqn1 eqn2
    handle Error err =>
      raise Error ("Rule.transEqn:\neqn1 = " ^ equationToString eqn1 ^
                   
*)

(* ------------------------------------------------------------------------- *)LiteralSet. litThm th then  litelseNONE
(* A conversion takes a term t and either:                                   *)t =(,) .refl)
(* 1. Returns a term u together with a theorem (stronger than) t = u \/ C.   *)
(* 2. Raises an Error exception.                                             *)
(* ------------------------------------------------------------------------- *)

type Termequal   then eqn2

    elseifTerm.equal x  thenreflEqn x

val noConv :conv= fn _ => raise Error "noConv";

(*MetisDebug
fun traceConv s conv tm       case equationLiteral eqn1 of
    
      val res as (tm',th) = conv tm
       (   (s^"  ^TermtoStringtm ^"--  ^
java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
    in
      res
    end
    handle Error err =>
      (trace (s ^ ": " ^ Term.toString tm ^ " --> Error: " ^ err ^ "\n");
       raise Error (s ^ ": " ^ err));
*)

funthenConvTrans  (,th1(',) =
    let
      
      and eqn2 = (tm'tm',)
      val(,th)=transEqn eqn1eqn2
    in
      (tm'',th)
    end;

fun thenConv conv1 conv2
    let
      val res1 as java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      val res2 = conv2tm
    in
      thenConvTrans tm res1 res2
    ;

fun orelseConv (conv1 : conv) conv2 tm = conv1 tm handle Error _ =      val (=trace( ^ :"^TermtoStringtm   -  

fun tryConv conv = orelseConv conv allConv      ( s^"   .toString tm   - Error   err^"n";

fun changedConv conv tm =
    let
      val res as (tm',_) = conv tm
    in
      if tm = tm' then raise Error "changedConv" else res
    d;

fun  convtm=tryConv thenConvconv (epeatConvconv))tm;

fun firstConv      val res2 =conv2tm'
| firstConv[onv  =convtm
   firstConv conv: convs tm  orelseConvconv (firstConvconvs) tm;

fun everyConv [] tm = allConv tm
| conv]  =convtm
  | everyConv (conv :: convs) tm = thenConv conv (everyConv convs) tm;

 conv   conv tm
    if Term.
    else  List. path then (,eqTh)
    else
      let
        val      if List.null paththen yeqTh
=Thm.destUnit reflTh
        val th = Thm.equality reflLit          th  Thm.equality reflLit : ) y
         =ThmresolvereflLitreflTh th
                tm,th)
            valrewrConv  fn eqn as (x,)eqTh)= fn path >fntm =
              NONE => th
                handle Error err =
       Error(".rewrConv\nx=  ^ .toStringx ^
      in
        (tm',th)
      end;

(*MetisDebug
  = fn eqn as (xy,) =fnpath=>fntm=
    rewrConv eqn path tm
    handle Error err =>
      raise Error ("Rule.rewrConv:\nx = " ^ Term.toString x ^
                   "\ny = " ^ Term.toString y ^
                   "\neqTh = " ^ Thm.toString eqTh ^
                   "\npath = "val(,h = x
                  \ntm   ^ Term.toString  ^ \"^err;
*)

fun pathConv conv path tm =
    let
      val x = Term.subterm tm path
      val (y,th) = conv x
    in
      rewrConv ((x,y),th) path tm
    end

funsubtermConv  i  pathConvconv[]

funsubtermsConv_ (mas TermVar =allConv
  | subtermsConv conv (tm
    everyConv (List.map (subtermConv conv) (interval

(* ------------------------------------------------------------------------- *)
(* Applying a conversion to every subterm, with some traversal strategy.     *)
(* ------------------------------------------------------------------------- *)

 bottomUpConv tm=
    thenConv (subtermsConvthenConvrepeatConvconv subtermsConvtopDownConv ))tm;

fun topDownConv conv let
    thenConv( conv)(ubtermsConvtopDownConv))tm;

fun repeatTopDownConv conv =
    let
      fun f tm = thenConvand  =thenConv subtermsConv)h java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
      and g tm = thenConv (subtermsConv f) h tm
      and h tm = tryConv (thenConv conv f) tm
    in
      f
    end;

(*MetisDebug
  =fnconv >fn  =>
    repeatTopDownConv conv tm
    handle---------------------------------------*java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
*)

(* ------------------------------------------------------------------------- *)
(* A literule (bad pun) takes a literal L and either:                        *) (it,h1 =literule1lit
(* 1. Returns a literal L' with a theorem (stronger than) ~L \/ L' \/ C.     *)
(* 2. Raises an Error exception.                                             *)
(* ------------------------------------------------------------------------- *)

type literule      ifLiteralequallitlit'  res2

fun allLiterule lit =       ifLiteralequal lit  allLiterulelit

if Thm lit')thenth1

fun thenLiterule literule1 literule2 lit =
    let
      valres1 litth1=literule1 lit
      val res2 as (lit''        else Thmresolve lit th1 th2
      (  literule literule2 litjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
      if Literal.equal lit lit' then
      else if    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
      else if Literal    in
      else
        (lit'',
         java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         elseifnot (.negateMember' ) then th2
         elsejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    end;

fun  |firstLiteruleliterule] lit= literule lit
    literule1  handle Error _ => literule2;

fun tryLiterule literule = everyLiterule[ lit =allLiterule lit

fun changedLiterule lit=
    let
      val res as (lit',_) = literule lit
    in
      if lit = lit' then raise Error "changedLiterule" else res
    end;

fun repeatLiterule
tryLiterule( literule( literule) lit;

fun firstLiterule []      Term. x  then allLiterule lit
  | firstLiterule [literule] lit = literule lit
  | firstLiterule (literule :: literules) lit =
    orelseLiterule literule (firstLiterule literules) lit;

fun everyLiterule [] lit = allLiterule lit
 | everyLiterule [] lit = literule lit
  | everyLiterule (literule :: literules) lit =
    thenLiterule literule (everyLiterule literulesiterules)lit;

fun rewrLiterule (eqn as ((x,y),eqTh)) path lit =
    if Term.equal x y then allLiterule lit
    else
      let
        val th = Thm.equality lit path y
        val th              NONE => th
case equationLiteral
NONE
            | SOME x_y => Thm.resolve      in
        val lit' = Literal.replace        end;
      in
        (lit',th)
      end;

(*MetisDebug
val rewrLiterule = fn eqn => fn path => fn lit =>
    rewrLiterule eqn path lit
    handle Error err =>
      raise Error ("Rule.rewrLiterule:\neqn = " ^ equationToString eqn ^
                   "\npath = " ^ Term.pathToString path ^
                   "\nlit = " ^ Literal.toString lit ^ "\n" ^ err);
*)

fun pathLiterule conv path lit =
    let
            val ('th   tm
      val (tm'      rewrLiterule ((,tm),) path lit
    in
      rewrLiterule ((tm    end;
    end;

fun argumentLiterule argumentLiterule i  pathLiteruleconvi]java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52

fun
    everyLiterule
      (List.(

(* ------------------------------------------------------------------------- *)
(* A rule takes one theorem and either deduces another or raises an Error    *)
(* exception.                                                                *)
(* ------------------------------------------------------------------------- *)

type rule = Thm.thm -> Thm.thm;

  :rule fnth>th;

 noRule:rule  fn_= raiseErrornoRule;

fun thenRule (rule1 : rule) (rule2 : rule) th = 

fun orelseRule (rule1 rule ;

 tryRule rule=orelseRule  allRule

fun changedRule rule th =
    let
      val th'    
    in
      if not (LiteralSetelse raiseErrorchangedRule"
      else raise Error "changedRule"
    end;

fun repeatRule rule lit =tryRule (thenRule rule (repeatRulerule)) lit

  [   raise "firstRule"
   firstRule[rule th=ruleth
  | firstRule (rule :: rules) th = orelseRule rule (firstRule rules) th;

 everyRulethallRuleth
  | everyRule [rule] th = rule th
  | java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

fun  litjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    let
      val(')=literule lit
    in
      if Literal.equal lit lit' then th
elseif not (.negateMember  litThthenlitTh
      else Thm;
    end;

(*MetisDebug
val literalRule = fn literule =>     literule lit java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    literalRule literule lit th
    handle Error err =>
raiseError "Rule.:\  "^LiteraltoStringlit^
                   "\nth = " ^ Thm.toString th ^ "\n" ^ err);
*)

   lit =literalRule( eqTh) lit

fun pathRule conv      funf lit) =

fun literalsRule literule =
    let
      fun f (itth 
          if Thm.member lit th then literalRule literule lit th else th
    in
      fnlits >fnth = LiteralSetfoldl  lits
    end;

  literuleth =literalsRuleliterule (hmclauseth) th;

fun java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

(* ------------------------------------------------------------------------- *)
(*                                                                           *)
(* ---------------------------------------------- functionCongruence (f,n)   *)
(*   ~(x0 = y0) \/ ... \/ ~(x{n-1} = y{n-1}) \/                              *)
(*   f x0 ... x{n-1} = f y0 ... y{n-1}                                       *)
(* ------------------------------------------------------------------------- *)let

fun functionCongruence (f,n) =
    let
      val xsfun  ((,yi,(h,)) =
      and ys = List.tabulate (            val = 1]

      fun cong ((i,yi),(th              =Literal litpathyi
          let
            val path = [          end
            val        =Thm (.Fnfxs
place (path,i)
          in
            (th,lit)
          end

      val reflTh = Thm.refl (Term.    in
      valreflLit=Thm. reflTh
    in
      fst (List.foldl cong (reflTh,reflLit) (enumerate     end;
    end;

(* ------------------------------------------------------------------------- *)
(*                                                                           *)
(* ---------------------------------------------- relationCongruence (R,n)   *)
(*   ~(x0 = y0) \/ ... \/ ~(x{n-1} = y{n-1}) \/                              *)
(*   ~R x0 ... x{n-1} \/ R y0 ... y{n-1}                                     *)
(* ------------------------------------------------------------------------- *)

fun relationCongruence (R,n) =
    let
      val xs = List.tabulate (,xIVar
      and

      fun  ((i,i)(,)) =
          let
            val path = [i]
            val th = Thm.resolve lit th (Thm.equality        xs= List.tabulate (xIVar
            val lit = Literal.replace lit 
          
            (th,lit)
          end

      val assumeLit=(,(R,))
      val assumeTh = Thm.assume assumeLit              = Literal.replacelit(ath,)
    in
      fst (List.foldl cong
    end;

(* ------------------------------------------------------------------------- *)
(*   ~(x = y) \/ C                                                           *)
(* ----------------- symNeq ~(x = y)                                         *)
(*   ~(y = x) \/ C                                                           *)
(* ------------------------------------------------------------------------- *)

fun symNeq lit th =
    let
      val (x,y) = Literal.destNeq lit
    in
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      else
        let
          val 
          val symTh = Thm           sub =Subst. [(xVarNamey)(,x]
        in
          Thm.resolve lit th symTh
        end
    endjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8

(* ------------------------------------------------------------------------- *)
(* sym (x = y) = symEq (x = y)  /\  sym ~(x = y) = symNeq ~(x = y)           *)
(* ------------------------------------------------------------------------- *)

fun sym (lit as (pol,_)) th = if pol then

(* ------------------------------------------------------------------------- *)
(*   ~(x = x) \/ C                                                           *)
(* ----------------- removeIrrefl                                            *)
(*         C                                                                 *)
(*                                                                           *)
(* where all irreflexive equalities.                                         *)
(* ------------------------------------------------------------------------- *)

local
  fun irrefl ((true,_),th) = th
    | irrefl (lit as (false,atm), th) =
      case total Atom.destRefl
        SOME xjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
      | NONE> th;
in
 = .foldlirrefl th (Thm.clauseth;
end;

(* ------------------------------------------------------------------------- *)
(*   x = y \/ y = x \/ C                                                     *) th LiteralSetfoldl  (.clause)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
(* ----------------------- removeSym                                         *)
(*       x = y \/ C                                                          *)
(*                                                                           *)
(* where all duplicate copies of equalities and disequalities are removed.   *)
(* ------------------------------------------------------------------------- *)

local
   rem (it as(,atm eqs_thas eqs) java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
      case total Atom.sym  (lit (,atmeqs_th eqs) =
h
      | SOME atmNONE>eqs_th
ifLiteralSet.memberlit then
                   LiteralSetmember lit eqsthen
else
          (LiteralSet.add eqselse
in
  fun removeSym th =
      snd (LiteralSet.foldl rem (LiteralSet.empty,th) (Thm.clause th));
end;

(* ------------------------------------------------------------------------- *)
(*   ~(v = t) \/ C                                                           *)
(* ----------------- expandAbbrevs                                           *)
(*      C[t/v]                                                               *)
(*                                                                           *)
(* where t must not contain any occurrence of the variable v.                *)
(* ------------------------------------------------------------------------- *)

local
  fun expand lit
      let
        val (,)  LiteraldestNeq
        val   Term.sTypedVarxorelse TermisTypedVar java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
                raise Error " =Term.isTypedVar   TermisTypedVaryorelse
        val _ = not (Term.equal x y) orelse
                raiseError"Rule.: equalvarsjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
      in
        Subst.unify Subst.empty x y
      end;
in
  fun expandAbbrevs 
      case LiteralSet.firstl (total expand
        NONE => removeIrrefl th
      | SOME sub => expandAbbrevs (Thm.subst sub th);
end;

(* ------------------------------------------------------------------------- *)
(* simplify = isTautology + expandAbbrevs + removeSym                        *)
(* ------------------------------------------------------------------------- *)

fun simplify th =end;
    if Thmjava.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
    else
java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 9
        val th' = th
        val th' = expandAbbrevs th'
        val th' = removeSym th'
      in
        if Thm.equal th th' then        val th'=removeSym th
      end;

(* ------------------------------------------------------------------------- *)
(*    C                                                                      *)
(* -------- freshVars                                                        *)
(*   C[s]                                                                    *)
(*                                                                           *)
(* where s is a renaming substitution chosen so that all of the variables in *)
(* C are replaced by fresh variables.                                        *)
(* ------------------------------------------------------------------------- *)

fun freshVars th = Thm.subst (Subst.freshVars (Thm.freeVars th

(* ------------------------------------------------------------------------- *)
(*               C                                                           *)
(* ---------------------------- factor                                       *)
(*   C_s_1, C_s_2, ..., C_s_n                                                *)
(*                                                                           *)
(* where each s_i is a substitution that factors C, meaning that the theorem *)
(*                                                                           *)
(*   C_s_i = (removeIrrefl o removeSym o Thm.subst s_i) C                    *)
(*                                                                           *)
(* has fewer literals than C.                                                *)
(*                                                                           *)
(* Also, if s is any substitution that factors C, then one of the s_i will   *)
(* result in a theorem C_s_i that strictly subsumes the theorem C_s.         *)
(* ------------------------------------------------------------------------- *)

local
  datatype edge =
      FactorEdge of Atom.atom * Atom
    | ReflEdge of Term.term * Term.term;

  fun ppEdge (FactorEdge atm_atm') 
    | ppEdge (ReflEdge tm_tm') = Print.ppPair Term(* ------------------------------------------------------------------------- *)

  datatype joinStatus =
      Joined
|  ofSubstsubst
    | Apart;

  fun joinEdge sub edge =
      let
        val result =
java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 24
              FactorEdge (atm,atm')     ppEdge (ReflEdge tm_tm') =Print.ppPair.ppTerm.pp tm_tm;
            | ReflEdge
      in
        case result of
          NONE =     Apart;
        | SOME subjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          if Portable.pointerEqual
      end;

  fun        valresult
      let
        fun update acc [] = SOME acc
          | update acc (edge :: edges) =
            casejoinEdge subedge
              Joined => NONE
             Joinable _= update (edge:: ) edges
            | Apart => 
      in
        update []
      end;

  fun addFactorEdge (pol,atm) ((pol',atm'),acc) =
      if pol< pol thenacc
      else
        let
          val edge = FactorEdge (atm,atm')
        in
          case joinEdge Subst.empty edge   funupdateApartsub=
            Joined => raise Bug "addFactorEdge: joined"
          
          | Apart> acc
        end;

  fun addReflEdge (false,_) acc =               Joined= NONE
    | addReflEdge (true,atm) acc =
      let
        valedge=ReflEdge(.destEqatm)
      in
        case joinEdge Subst.empty edge of
          Joined => raise Bug "addRefl: joined"
        | Joinable _ => edge :        []
        | Apart => acc
      end;

  fun addIrreflEdge (true,      if pol > pol then acc
     addIrreflEdge false)accjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
      let
        val  = ReflEdge (AtomdestEq atm
      in
casejoinEdge.empty of
          |Joinable >(,edge : acc
        | Joinable sub => (sub,edge) :: acc
        | Apart => acc          | Apart=>acc
      end;

  fun init_edges acc _ [] =
      let
        fun
            (edge ::valedge =ReflEdgeAtom. atm
      in
        snd (.foldl [,] )
      end
     init_edges acc (sub) ::sub_edges =
      let
(*MetisDebug
        val () = if not (Subst.null sub) then ()
                 
*)
        val (acc,apart) =
            case updateApart sub apart of
              SOME apart' => ((apart',sub,edge) :: acc, edge :: apart)
            | NONE => (acc,apart)
      in
        init_edges acc apart sub_edges      in
      end

   mk_edgesapart sub_edges[  init_edges [ apartsub_edges
    | mk_edges apart sub_edges (lit :: lits) =
      let
        (

        val                    Bug"..:  subst"
            case total Literal.sym lit of
        val (,apart java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
            | SOME lit' =>
              let
                val apart = addReflEdge litinit_edges  apartjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
                val sub_edges = addIrreflEdge lit sub_edges
                val sub_edges = List.foldl (addFactorEdge      
              in
                (apart,sub_edges)
              end
      in
        mk_edges apart sub_edgesjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
      

  fun fact acc []                   =addReflEdge  java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    | fact acc ((_,sub
    | fact acc
      let
        val others =
            case
              Joinable sub' =>
              java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
                val others = (edgelet
              in
                case updateApart sub' apart of
                  NONE => others
                |SOME apart'= apart,ub'edges : java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
                              case updateApart sub'apartof
            | _ => (apart,sub,edges) :: others
      in
        fact accend
      end;
in
  fun factor' cl =
      let
(*MetisTrace6
        val () = Print.trace LiteralSet.pp "   factor' cl =
*)
        val edges = mk_edges [] [] (LiteralSet.toList cl)
(*MetisTrace6
        val ppEdgesSize = Print.ppMap length Print.ppInt
        val          ppEdgesSize  PrintppMaplengthPrint.java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
        val ppEdges = Print.ppList (Print.ppTriple ppEdgel Subst.pp ppEdgel)
        val () = Print.trace ppEdgesSize "Rule.factor': |edges|" edges
        val () = Print.trace ppEdges "Rule.factor': edges" edges
*)
        val result = fact [] edges

        val ppResult
        end
*)
      in
        result
      end
end;

fun factor th =
    let
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    in
      List.map fact (factor' (Thm.clause th))
    end;

end