+ =====================================================================	+
|									|
| LIBRARY	: more_utils						|
| 									|
| DESCRIPTION   : A miscellany of useful proof tools.                   |
|									|
| AUTHOR	: Ralf Reetz					        |
| e-mail        : reetz@ira.uka.de                                      |
|   WWW         :    http://goethe.ira.uka.de/people/reetz/reetz.html   |
|                                                                       |
| AFFILIATION   : University of Karlsruhe                               |
|                 Institut fuer Rechnerentwurf und Fehlertoleranz       |
|                 76128 Karlsruhe, Zirkel 2, Postfach 6980, Germany     |
| DATE		: 5th October 1994 		         		|
+ ===================================================================== +


+ --------------------------------------------------------------------- +
|									|
| DOCUMENTATION:							|
|									|
+ --------------------------------------------------------------------- +

This library provides a selection of useful derived rules and tactics
that have been developed at Karlsruhe. Also, there is a utility for
benchmarking inference rules. 

(************************************************************************)
(*   No_UNDISCH_TAC                                                     *)
(*     Takes a number ni and undischarges the ni-th assumption. E.g.    *)
(*     No_UNDISCH_TAC 1 undischarges the first assumption.              *)
(*                                                                      *)
(*   ALL_UNDISCH_TAC                                                    *)
(*     undischarges all assumptions.                                    *)
(*                                                                      *)
(*   No_DISCARD_ASSUM_TAC                                               *)
(*     Takes a number ni and throws the ni-th assumption away. E.g.     *)
(*     No_DISCARD_ASSUM_TAC 1 throws the first assumption away.         *)
(*                                                                      *)
(*   ALL_DISCARD_ASSUM_TAC                                              *)
(*     throws all assumptions away.                                     *)
(*                                                                      *)
(*   No_RULE_ASSUM_TAC                                                  *)
(*     Takes a number ni and maps an inference rule over the ni-th      *)
(*     assumption. E.g. RULE_ASSUM_No_TAC 1 rules an inference rule     *)
(*     over the first assumption.                                       *)
(*                                                                      *)
(*   No_POP_ASSUM                                                       *)
(*     Takes a number ni applies tactic generated from the ni-th        *)
(*     element of a goal's assumption list. E.g. No_POP_ASSUM 1 is the  *)
(*     same as POP_ASSUM.                                               *)
(*                                                                      *)
(*   RES_CONTR_TAC                                                      *)
(*     solves a goal, if there is a theorem |- A and it's contradiction *)
(*     |- ~A in the assumption list of the goal.                        *)
(*                                                                      *)
(*   mk_thm_TAC                                                         *)
(*     proves every goal (should be used for test purposes only!)       *)
(*                                                                      *)
(*   SELECT_EXISTS_TAC (from Klaus Schneider)                     	*)
(*								        *)
(* 			G |- Q(@x.P x)				        *)
(*		==================================		        *)
(* 		G |- ?x.P x	G |- !y.P y==> Q y		        *)
(*								        *)
(*     The term @x.P x has to be given as argument. The tactic will     *)
(*     then eliminate this term in Q and the subgoals above are  	*)
(*     obtained. This tactic only makes sense if G|-?x.P x holds. 	*)
(*     Otherwise the tactic SELECT_TAC should be used.          	*)
(*                                                                      *)
(*   SELECT_TAC (from Klaus Schneider)                                  *)
(*						        		*)
(*			G |- Q(@x.P x)				        *)
(* 	   ==========================================	          	*)
(*	    G |-(?x.P x) => !y. P y ==> Q y | !y.Q y		        *)
(*								        *)
(*   SELECT_UNIQUE_RULE, SELECT_UNIQUE_TAC (J. Harrison)         	*)
(*								        *)
(*       "y"   A1 |- Q[y]  A2 |- !x y.(Q[x]/\Q[y]) ==> (x=y)        	*)
(*        ===================================================	        *)
(*                A1 U A2 |- (@x.Q[x]) = y			        *)
(*								        *)
(*    Permits substitution for values specified by the Hilbert Choice  	*)
(*    operator with a specific value, if and only if unique existance   *)
(*    of the specific value is proven.	                		*)
(*                                                                      *)
(*                                                                      *)
(*   output_benchmark                                                   *)
(*                                                                      *)
(*    A tool for performing benchmarks. Measures proof time and         *)
(*    number of rules applied.                                          *)
(*                                                                      *)
(************************************************************************)

More detailed documentation can be found in the "help" directory.


+ --------------------------------------------------------------------- +
|									|
| TO REBUILD THE LIBRARY:						|
|									|
+ --------------------------------------------------------------------- +
                                      
   0) make_more_utils <hol90>

+ --------------------------------------------------------------------- +
|									|
| TO USE THE LIBRARY:							|
|									|
+ --------------------------------------------------------------------- +

Alternatives:

    0) load_library{lib = find_library "more_utils", theory = <foo>};

    1) prim_load_library Lib.interpret 
                {lib = find_library "more_utils", theory = <foo>};

