EDITS TO THE ISABELLE SYSTEM FOR 1992

24 January 

HOL/ruleshell,lemmas: renamed eps to select
HOL/lemmas/ext: deleted; abs is easier to use

HOL/list: getting rid of ERS, since it seems to work only for notI and impI
Instead, proofs are stated using negation or implies; related versions are
obtained by RS with notE, mp.

FOL/int-prover/contrapos: new

HOL/lemmas: replaced contra_positive by contrapos, from FOL

HOL/sum,nat,sexp: proved _not_ first

HOL/fun: tidied lemmas about One_One and One_One_on -- these predicates are
more useful than rules expressing the same concepts

HOL/nat,sexp: recast proofs to use One_One and One_One_on

27 January

HOL/fun/inverse_imp_injective: deleted; use One_One_on_inverseI RS One_One_onD
    val prems = goal Class.thy
	"[| f(x)=f(y);  !!x. P(x) ==> g(f(x)) = x;  P(x);  P(y) |] ==> x=y";
    br (apply_inverse RS trans) 1;
    by (REPEAT (ares_tac prems 1));
    val inverse_imp_injective = result();

HOL built perfectly

3 March

Introduction of goal commands taking cterms rather than strings

Pure/goal/prove_goal: takes a cterm, not a thy and string; catches
exception THM (typically from "assume")

Pure/goal/ADDED
  val goalw_cterm:     thm list -> Sign.cterm -> thm list
  val prove_goalw_cterm: thm list->Sign.cterm->(thm list->tactic list)->thm

Pure/thm: improved the error messages in many rules

4 March

Pure/logic/varify: added a case for Var.

5 March

changed T_of_term to pretty_term in Pure/sign.ML Pure/tctical.ML
Pure/unify.ML Pure/SYNTAX/printer.ML Pure/SYNTAX/syntax.ML

Pure/sign: added
  val string_of_cterm: cterm -> string
  val string_of_term: sg -> term -> string

Pure/tctical: added
  val string_of_thm: thm -> string

12 March

MAKE-ALL (SML of NJ, v 0.75) PERFECT!  Took 1:19 hours (on SPARCstation,

Modal: re-instated Rajeev Gore's rules for S43.

5 April

Implemented infix type constructors. Most changes in SYNTAX.
Two new syntax directives TInfixl and TInfixr.

Proved simultaneous fixpoint induction in LCF.

Incorporated type infixes into HOL.

Fixed priority of type and sort constraints (::) as follows:

1. expr :: type binds most tightly
2. type :: sort binds most tightly
3. expr :: type1 :: type2 is parsed as expr :: (type1 :: sort)
   and should therefore be written (expr :: type1) :: type2

Also fine-tuned the grammar for types. Hope it works better now.

**** NEW SYSTEM FROM TOBY ****

6 April

Pure/thm/stamps_of: new, for inspecting a theory
  val stamps_of: theory -> string ref list

Pure/tctical/prthq: for inspecting the output of a tactic, etc.
  val prthq: thm Sequence.seq -> thm Sequence.seq

Pure/tctical: improved error messages in RSN

Pure/sign/print_term, print_cterm: deleted; use writeln(string_of_term ...)

Pure/goals/prin, Pure/tctical/print_goals,
Provers/simp/pr_goal,pr_goal_concl: no longer call print_term

Pure/goals/curr_prems: this ref is no longer exported, since users should
not be able to change it.

Pure/goals/premises: new function to return the contents of curr_prems

Pure/unify/matchcopy: removed the following code, which (intentionally!)
disabled the solution of "recursive" disgreement pairs.  The example
"ALL x. ?f(g(x))=g(?f(x))" now, correctly, generates infinitely many
unifiers (subject to Unify.search_bound).  Also 
goal HOL_Rule.thy "(%x.?f(g(x))) = (%x.g(?f(x)))" works.  WAS
	    if  w=v   (*v is destination of copy*)
	    then matchfun(rev(make_projs(Ts, targs)))
	    else 

Pure/tactic/forwards_tac: renamed and modified to take a list of thms; WAS
  fun forward_tac rule = bires_cut_tac [(true,rule)];

Modal/README,S43.ML: Acknowledged Gore'

Pure/unify/print_dpairs: improved quality of output using rlist_abs

CTT/ex/synth/"A tricky combination of when and split": deleted redundant
  by (TRYALL (resolve_tac [NF]));

CTT/ex/synth/"The addition function -- using explicit lambdas": replaced by
(resolve_tac comp_rls 3); with res_inst_tac -- the bug fix to the
unification algorithm was causing excessive branching.

HOL/subset/Inter_greatest: deleted redundant
  by (cut_facts_tac prems 1);

Pure/tctical/size_of_thm: new
FOL/ROOT,HOL/ROOT: no longer define their own size_of_thm

Pure/tactic/trace_goalno_tac: no longer must be used with THEN.  Was
    fun trace_goalno_tac i = Tactic (fn state =>
       (prs("Subgoal " ^ string_of_int i ^ " selected\n");
	Sequence.single state));

Pure/goals/frs,fes,fds,fa: now use new trace_goalno_tac

ZF/func/fun_subset, ZF/ex/trancl, ZF/ex/wf/is_recfun_equal,ex_is_recfun,
CTT/arith/absdiff_eq0: reduced usage of REPEAT_FIRST 

Pure/term,logic,sign,tactic,tctical,thm,unify, FOL/simpdata: renamed
TERM_ERROR to TERM

Pure/goals/getgoal,top_sg: simplified to use topthm rather than apply_fun
Pure/goals/print_exn: new

Pure/tctical/unify_instantiate: renamed as cterm_instantiate
Provers/hypsubst,simp: now call cterm_instantiate

Pure/tctical/read_instantiate: no longer takes a theory

FOL/int-prover/pred_congs,eq_cong, LCF/fix/ffix,gfix, LCF/pair/ppair,qpair
FOL/ex/cla/Problem 58, ZF/ex/perm/cf_cong, HOL/ex/arith:ss1: take new
read_instantiate

Pure/sequence/filters: new

Pure/tctical: added
  val CHANGED: tactic -> tactic
  val FILTER: (thm -> bool) -> tactic -> tactic

** Abolishing ?Ga variables in unification -- preserving existing names

Pure/envir/genvar,genvars: now take a name as prefix, rather than "G".  No
letter suffix is attached to the last name generated -- this means that
genvar does not attach a suffix at all.

Pure/unify/make_args: now takes a name as prefix

Modal/Makefile*: deleted rule that makes .rules.ML

7 April

MAKE-ALL (Poly/ML) Perfect except for HOL.

HOL/ex/prop-log/comp_lemma: removed a needless use of res_inst_tac, which
had referred to a "Ga" variable.

ZF/ex: removed all "reslist"

Pure/tctical: deleted the almost useless
  fun MAP_EVERY tacf xs = EVERY (map tacf xs);
  fun MAP_FIRST tacf xs = FIRST (map tacf xs);

Pure/tactic/cut_facts_tac: removed usage of MAP_EVERY

Pure/tctical/reslist: deleted as obsolete
    (*List of all resolvents of ths with thb at i*)
    fun reslist (ths,i,thb) = 
      Sequence.list_of_s (resolution (thb,i,ths));

Pure/tctical/RL, Provers/classical: no longer calls reslist

Pure/thm/equal_props: renamed to equal_elim (since that's what it is!)
Pure/tactic/fconv_rule: now calls equal_elim

MAKE-ALL (Poly/ML) PERFECT.  New tar file put on /homes/lcp. 

8 April

CTT/ex/elim/"Double negation of the Excluded Middle": new
CTT/ex/*: used expandshort

Pure/thm: added
  val axioms_of: theory -> (string*thm)list
  val parents_of: theory -> theory list

Pure/thm: deleted the useless
  val kind_of_theory: theory -> string   

LK/ruleshell: some variable renaming, but variable name preservation
(still) does not work because of the representation of sequences.

MAKE-ALL (Poly/ML) PERFECT.  New tar file put on /homes/lcp. 

13 April

Pure/goals/prepare_proof: now uresult does no checking at all
Pure/goals/by_com, pop: improved error messages
Pure/goals/chop_level: now checks range

*** preventing signature changes during proofs ***

Pure/tctical: exported eq_sg and defined eq_thm_eq
  val eq_sq: Sign.sg * Sign.sg -> bool
  val eq_thm_eq: thm * thm -> bool

CTT/ex/synth: last 2 examples now proved in arith_thy, not CTT_Rule.thy

14 April

MAKE-ALL (Poly/ML) PERFECT.  New tar file put on /homes/lcp. 

24 April

FOL/ex/cla: added several problems from MLbook/test10.ML

MAKE-ALL (Poly/ML) PERFECT.  New tar file put on /homes/lcp. 

4 May

logic/strip_assums: moved down to assum_pairs, the only place where it is
called

6 May updated README

6 July ****************************************************************
******** RECEIVED ISABELLE-92 FROM TOBY *******************************

6 July

README: updated and changed expandshort.sh to expandshort; documented
teeinput

agrep: added Modal

get-rulenames: now accepts ext_theory as well as extend_theory.  Now
accepts a [ before a rulename.

SYNTAX: trimmed down signature SYNTAX to include only the items that people
actually use, and made Syntax "open"

SYNTAX: suppressed Warning: no productions for ANY1

FOL/ex/intro.ML,prolog.ML: from text/Doc/Intro

FOL/ex/cla.ML, FOL/int-prover, from ~/newisa/cla.ML
(added all_dupE and FOL_dup_cs)

FOL/int-prover/mp_tac,eq_mp_tac: notE,impE were in wrong order

FOL/cla-lemmas/notnotE: replaced by notnotD: ~~P ==> P
WAS  "[| ~~P;  P ==> Q |] ==> Q"

ZF/syntax,ruleshell,lemmas: deleted <! (unused, and not a natural relation
in set theory).

ZF/ex/perm: moved converse to standard ZF theory.  Affects syntax,
ruleshell, domrange, ex/mono.

ZF/lemmas: DELETED
    val [major] = goal set_thy "A<=0 ==> A=0";
    by (rtac (empty_subsetI RS (major RS equalityI)) 1);
    val empty_subsetD = result();

    val prems = goal set_thy "a:A ==> ~ A=0";
    by (rtac notI 1);
    by (etac equals0D 1);
    by (resolve_tac prems 1);
    val nonemptyI = result();

    val prems = goal set_thy "[| ~ A=0;  !!y. y:A ==> P |] ==> P";
    by (cut_facts_tac prems 1);
    by (REPEAT (swap_res_tac ([equals0I]@prems) 1));
    val nonemptyE = result();

also PrimReplaceI, PrimReplaceE

ZF/lemmas/bexXI: renamed bexCI; other XI rules deleted

ZF/subset: DELETED Union_upperbound Inter_lowerbound Un_upperbound1
Un_upperbound2 Int_lowerbound1 Int_lowerbound2 cons_refl

ZF/lemmas: added INT_I, INT_E

ZF/domrange: replaced proofs for domain, range to use new defns.

7 July

ZF/pair/SigmaD1,SigmaD2: new

expandshort: now takes a list of filenames in the command line

ZF/ex/equalities: added distibutive laws involving Sigma, Int and Un

ZF/pair: changed all (SUM x:A.B(x)) to Sigma(A,B)
ZF/func: changed all (PROD x:A.B(x)) to Pi(A,B)

HOL/lemmas/notnotE: replaced by notnotD: ~~P ==>  P
HOL/lemmas/all_dupE: new

HOL/ex/cla: new, general test of classical prover (for predicate calculus)
HOL/ex/meson, HOL/ex/meson-test: new

Pelletier's problems (FOL/ex/cla, HOL/ex/cla, LK/ex): changed 12 to all <->
and corrected 39 and 40

LK/ex/prop,quant/hard-quant: replaced by those from newisa (using updated
tactics) 

Provers/classical: from newisa; updated definitions in FOL, HOL

8 July

LK/syntax: True->Trueprop;  changed "<SP> to "@; Forall->All; Exists->Ex;

LK/syntax,ruleshell,resolve: added True, False

LK/syntax: removed the string definitions at the head of the file
LK/resolve: replaced from newisa (with updated tactics) 

Modal/ruleshell: changed "<SP> to "@

CTT/ruleshell: tidied the subst rules 
CTT/resolve/safestep_tac: put in signature.

Provers/hypsubst/inspect_pair: now rejects recursive equations, i.e. x=t[x]
and t[x]=x, where x may be free or bound.  Substitution for these would not
eliminate x.

NJ/cond_timeit: now suppresses trailing zeroes.

Pure/tctical/added
  val IF_UNSOLVED: tactic -> tactic
  val THEN_BEST_FIRST: tactic * ((thm->bool) * (thm->int) * tactic) -> tactic

Pure/tctical/select: simplified, since nasms = 0

Pure/tctical/THEN, THEN', THEN_BEST_FIRST now have precedence 1
(higher than ORELSE APPEND INTLEAVE)

Pure/tctical/show_hyps: new, used in pretty_thm to allow suppressing
hypotheses in printing

Pure/thm/stamps_of: renamed stamps_of_thy
Pure/thm/stamps_of_thm: new

HOL/subset/set_cs: removed addXIs (no longer available)

9 July

Pure/thm/bicompose_aux: added a flag to permit detection of a "match" (not
updating variables in proof state) Add "match" flag to bicompose_aux,
bicompose, biresolution.  Changed types:
  val bicompose: bool -> bool * thm * int -> int -> thm -> thm Sequence.seq   
  val biresolution: bool -> (bool*thm)list -> int -> thm -> thm Sequence.seq   

Pure/thm/resolution: DELETED (its a trivial instance of biresolution,
called only twice).

Pure/tctical/RSN,RLN,compose,protect_subgoal,select: new argument order for
biresolution, bicompose

Pure/tactic/bimatch_tac, match_tac, ematch_tac, dmatch_tac: new

Provers/classical/safe_step_tac,eq_mp_tac: now use matching, not resolution
Provers/classical/inst_step_tac: now tries safe rules using resolution

FOL/ROOT/prop_cs: refl is now regarded as safe!

ZF/pair/pair_cs: Pair_neq_0, succ_neq_0 are now safe

ZF/domrange/ZF_cs: converseI, converseE are now safe

Provers/classical: no longer calls mp_tac since it can never succeed.
FOL/ex/cla now runs faster than before.  Perhaps eq_mp_tac should also go.

HOL/equalities.ML,fun.ML,mono.ML,prod.ML,set.ML,subset.ML,ex/set.ML:
changed Class to Set.

ZF/lemmas/ball_tac,set_mp_tac: redefined using dtac and assume_tac
ZF/lemmas/ballE': new

10 July

HOL/ex/arith/mod_quo_equality: added a call to rename_tac, since meson.ML
switched off var name preservation

Pure/unify/add_ffpair: now exchanges the variables if necessary to
encourage updating the LARGER variable.  Thus it is less likely to update
the proof state.

Provers/hypsubst: attempted to replace XXresolve_tac by XXmatch_tac and to
allow substitution for Vars, but it did not work (looping in the
Schroeder-Bernstein proof!)

Pure/tctical/aconvs: moved to term

Pure/unify/decreasing: new, to test whether a new variable is redundant 
Pure/unify/clean_term: no longer generates a new variable when the old one
will do.  This makes LK proofs look better.  The Schroeder-Bernstein proof on
demo.ML still suffers variable renaming, because of nontrivial flex-flex pairs.

13 July

Provers/classical/step_tac: no longer REPEATs inst_step_tac, since this
can loop

Provers/classical/inst_step_tac: uses APPEND' not INTLEAVE', to ensure that
rules are attempted in a sensible order.

HOL/ex/prop-log/MP: fast_tac can no longer do it without more hints.
Generally the changes have been improvements but not everything works as
before. 

14 July

FOL/ex/cla,HOL/ex/cla: the new classical tactics can no longer handle even
the following proof of 43:
    by (safe_tac FOL_cs);
    br allE 1;
    ba 1;
    by (REPEAT (etac allE 1));
    by (best_tac FOL_dup_cs 1);
    br allE 1;
    ba 1;
    by (REPEAT (etac allE 1));
    by (best_tac FOL_dup_cs 1);

expandshort: now leaves the old files as XXX~~ rather than old.XXX

LK/resolve/step_tac,fast_tac,best_tac: now uses matching rather than
RESOLVE_THEN.  Should now be "more" complete, but is almost twice as slow
as pc_tac.  ABANDONED -- fast_tac was much too slow!

HOL/ruleshell: deleted I since it is unused and is should be left as a
variable name.  WAS
  (["I"], "'a => 'a"),
  ("I_def",     "I = (%x::'a.x)"  ),

Pure/tctical/strip_context,forall_elim_list,implies_intr_list,LET_GOAL: new
Pure/goals/gethyps: new

15 July

MAKE-ALL failed on ZF and HOL

HOL/simpdata: deleted (I_def RS ap_thm RS sym,I_def RS ap_thm)

Pure/tactic/rewrite_goal_rule: deleted (use SELECT_GOAL).  WAS
    fun rewrite_goal_rule rths i =
	fconv_rule (goals_conv (curry op= i) (rew_conv rths));

Pure/tactic/rewrite_rule,rewrite_goals_rule: now test for the empty list of
rewrites

**************** ZF -- Incorporating Modules ****************

ZF/syntax: now declares a functor
ZF/ruleshell: was ZF/rules, now declares a functor
ZF/Makefile*: now refer to .rules.ML, not rules.ML
ZF/lemmas,upair,subset,pair,domrange: goal -> prove_goal
ZF/lemmas: now declares a functor

prove_goal.el: new Emacs command for changing goal to prove_goal

ZF/lemmas/prove_hazXI_tac: unused, deleted.  WAS
    (*Tactic for proving an "expansive" introduction rule, assuming the negated
      conclusion in all subgoals;  intr is the ordinary intro rule. *)
    fun prove_hazXI_tac prems intr =
	rtac classical 1 THEN
	rtac intr 1 THEN
	REPEAT (eresolve_tac (asm_rl::prems) 1);

Pure/goals/dummy: new, dummy initial proof state -- ensures that goal stack
never becomes empty.  (So prin will always work)
Pure/goals/undo_list: now initialized to dummy state.

Pure/tctical,Pure/goals,HOL/ex/meson: renamed LET_GOAL to METAHYPS

17 July

Pure/SYNTAX/basic-syntax.ML: deleted
Pure/SYNTAX/syntax: Included PRINTER0 in signature SYNTAX
Pure/SYNTAX/ROOT: defined Basic_Syntax directly
Pure/SYNTAX/sextension/mk_binder_tr,mk_binder_tr': new

HOL/ruleshell: now handles both HOL and Isabelle quantifier syntaxes
HOL/set,equalities,...: changed ALL, EX to !, ?
HOL/set/coll_tr,coll_tr': deleted; uses mk_binder_tr

ZF/syntax/coll_tr,coll_tr',the_tr,the_tr': deleted; uses mk_binder_tr, qnt_tr

HOL/lemmas/gen: deleted

HOL/ruleshell,simpdata,wf,ex/prop-log: changed p=>x|y to Cond(p,x,y) 
\([a-zA-Z0-9_']*\) *=> *\([a-zA-Z0-9_']*\) *| *\([a-zA-Z0-9_']*\)
Cond(\1,\2,\3)

A nice syntax might be [ p1=>x1 || ... || pn => xn || y]

HOL/set/iffD1,2: moved to lemmas, replacing eq_mp
HOL/ruleshell,lemmas: removed obsolete rule names: disj_cases, disch, truth

20 July

MAKE-ALL failed on HOL

HOL/ex/set: changed z:X => f(z) | g(z) to Cond(z:X, f(z), g(z))
HOL/ex/prop_log/max_imp,tt_asms_def: Cond
HOL/ex/term/Abs_map_lemma: Cond

HOL/wf/unfold_the_recfun: replaced ex_selectI by exE followed by
eres_inst_tac ... selectI

HOL/lemmas/ex_selectI: deleted
HOL/lemmas/iffI: redone using prove_goal

HOL/ruleshell/select: replaced by selectI and used @ notation (to get
variable name preservation)

HOL/set/anti_mono,Onto_subset: deleted since never used.
HOL/set,subset: changed NCompl...to Compl...
HOL/subset/*_upperbound,*_lowerbound: deleted since never used.

HOL/equalties: reordered proofs; re-expressed pairs of theorems as iffs
ZF/ex/equalities: tidied as above

21 July

HOL/nat/less_linear: was called less_trichotomy

HOL/set/mem_Collect_eq,Collect_mem_eq: new axioms, explicit isomorphisms
HOL/set/CollectI,CollectD,set_ext: now proved from the axioms

HOL/set: rules about image, range, mono moved to fun.ML

HOL/ROOT/HOL_thy: new, refers to the theory most recently defined
(currently List.thy)

22 July

make-all: now deletes LCF (as well as other images) at start of run

23 July

MAKE-ALL (Poly/ML) PERFECT.  Note that "make-all" jobs should be run withu
"nohup" to prevent their being killed upon logoff.

ZF/ex/mono.ML equalities.ML perm.ML plus.ML wf.ML ordinal.ML fixedpt.ML
trancl.ML nat.ML: these files moved to the main directory.  What good is ZF
without the naturals??

ZF/lemmas/equalityCE: new

Pure/forall_elim_list: was instantiating variables in reverse order!

Pure/SYNTAX/pretty/lst: now returns a Pretty.T (a block) instead of a list
of them!!

Pure/tctical/pretty_thm,print_goals: modified for new Pretty.lst

ZF/simpdata/ZF_atomize: was completely wrong, trying to call the FOL
version (atomize) for other cases!!  Did not handle P & (ALL x:A.Q)

ZF/simpdata/atomize: new, self-contained, hiding the FOL version

ZF/ex/misc: new, for standard challenge problems.  Proved Cantor's theorem
and "Composition of homomorphisms" today.

24 July

MAKE-ALL (Poly/ML) PERFECT.  New tar file placed on /homes/lcp

ZF/simpdata/memrews: added the rewrite "<a,b>: Sigma(A,B) <-> a:A & b:B(a)"

27 July

Pure/term/is_var: renamed is_Var to agree with dest_Var, etc.
Pure/thm.ML,ZF/simpdata.ML,CTT/resolve.ML: updated accordingly

Provers/simp/try_true: added a newline after message "Failed to prove
precondition"

ZF/wf: reorganized, reducing number of proofs involving the special setting
of auto_tac_ref.  Simplified proof of unfold_the_recfun, proving it
directly by induction rather than proving "EX f.is_recfun(r,H,f,a)"

FOL/int-prover/ssubst: calling "standard" reduces maxidx to 0

ZF/ordinal: redefined transrec to take only 1 ordinal as argument!
ZF/nat: nat_rec proofs modified accordingly
ZF/ex/arith: proofs involving transrec (mod, quo) modified accordingly

ZF/ordinal: many proofs simplified to use fast_tac
ZF/ordinal/Transset[ID}: deleted; use defs instead
    val prems = goalw Ord.thy [Transset_def]
	"(!!x. x:i ==> x<=i) ==> Transset(i)";
    by (REPEAT (ares_tac (prems@[ballI]) 1));
    val TranssetI = result();

    val [major,minor] = goalw Ord.thy [Transset_def]
	"[| Transset(i);  a:i |] ==> a<=i";
    by (rtac (minor RS (major RS bspec)) 1);
    val TranssetD = result();

29 July

ZF/wf: renamed wfrec as wftrec, the version requiring transitivity.  Now
wfrec uses trancl (as the last stage) and does not require transitivity

ZF/ordinal: simplified proofs involving transrec.

31 July

Pure/SYNTAX/syntax,Pure/SYNTAX/ROOT: changed "include sig1 ... sign" to
"include sig1 ... include sign" because New Jersey does not allow include
to take multiple signatures

ZF/simpdata/mem_rews: removed the following because EX statements are hard
to prove by rewriting (cannot instantiate B):
   "A: Union(C) <-> (EX B. B:C & A:B)",

3 August

MAKE-ALL (NJ) failed on ZF (for obvious reasons) and HOL.

92/HOL/Makefile.NJ: changed class.ML to set.ML

4 August

ZF/univ: new file (incorporating old ex/univ)

5 August

ZF/mono/Sigma_mono: deleted this synonym for product_mono (did not handle
general Sigma)

Swapping iffD1 and iffD2 (the old order just did not make sense!)
Affected files:
HOL/lemmas HOL/simpdata HOL/ex/prop-log
FOL/int-prover FOL/simpdata
LCF/simpdata
ZF/lemmas ZF/nat ZF/ordinal ZF/pair ZF/simpdata ZF/upair ZF/wf ZF/ex/misc

HOL: tested
FOL: rebuilt
LCF: tested
ZF: rebuilt & tested

ZF/ordinal/transrec: deleted the old definition of transrec (moved to
Isabelle/ordinal-relics) since the new version (currently called epsrec)
has precisely the same conversion law, and does not require an ordinal for
its argument.  

ZF/nat: defined nat_rec using wfrec rather than transrec
ZF/univ,ex/arith,etc.: now use the new transrec

ZF/ordinal/OrdD1: renamed Ord_is_Transset
ZF/ordinal/OrdD2: renamed Ord_contains_Transset

6 August

MAKE-ALL (Poly/ML) failed on ZF.

ZF/nat: repaired old ref to OrdD1

MAKE-ALL (NJ) went perfectly.

HOL: changed Cond to if throughout

HOL/sum: changed "when" to "case" to agree with other eliminators.

ZF/plus: renamed sum
ZF/sum,univ,ex/simult: renamed plusXX to sumXX and when to case

ZF/simpdata/mem_rews: removed the following because EX statements are hard
to prove by rewriting (cannot instantiate B):
   "(EX B. B:C) ==> A: Inter(C) <-> (ALL B. B:C --> A:B)",
   "b : RepFun(A,f) <-> (EX x. x:A & b=f(x))"

HOL/ruleshell/HOL_compat: renamed HOL_quantifiers

Pure/thm/add_rew: added a check to make meta-rewriting FAIL if the head of
the definition is flexible; this indicates a missing constant declaration

7 August

HOL/wf: simplifed proofs, esp of Main Lemma;  renamed wfrec to wftrec.
Defined a new version of wfrec that takes its arguments in a more
convenient order and does not require trans(r).

HOL/nat,list,sexp,ex/arith,ex/term,ex/simult: modified to use new wfrec
HOL: tested perfectly

FOL/int-prover: split as int-lemmas, int-prover.  Identifiers in int-prover
made to follow Provers/classical as much as possible.

10 August

MAKE-ALL (Poly/ML and NJ) went perfectly.

FOL/int-prover: added imp_negE; this had been omitted and made example 17
on ex/int.ML.

FOL: renamed Classical to Cla; the intuitionistic prover now resides in
structure Int.

FOL/ex/int: added more difficult (slow!) quantifier examples

FOL/simpdata: is now intuitionistic; was classical.  Had to delete certain
theorems...

FOL/simpdata/disj_rews:   "P | ~P", 		"~P | P",
FOL/simpdata/not_rews:   "~ ~ P <-> P"
FOL/simpdata/imp_rews:   "(~P --> P) <-> P"
FOL/simpdata/distrib_rews:   "~(P&Q) <-> ~P | ~Q",
"(P & Q --> R) <-> (P --> R) | (Q --> R)",
"~(ALL x.NORM(P(x))) <-> (EX x. ~NORM(P(x)))",

12 August

Provers/simp/rtr_resolve_tac,rtr_resolve_tac1: changed resolve_tac to
match_tac for better robustness in the presence of Vars during rewriting.

FOL/ex/list: modified the final theorem for the new version of SIMP_TAC

Pure/sign: modified by Toby to take account of default names of Vars. 
"Here is the problem with the previous version: if the goal contained ?P1
and ?P2 of different types, instantiating ?P1 may fail because the typing
mechanism may pick the type of ?P2 because it only looks at the string part
of indexname."

13 August

MAKE-ALL (Poly/ML) failed on ZF and HOL because of modified simplifier

ZF/wf,ex/misc,HOL/wf: beefed up the auto_tactic in order to compensate for
the stricter treatment of rewriting.

MAKE-ALL (NJ) failed on HOL.

HOL/ex/prop-log/comp_lemma: added some steps to force instantiation of a
variable. 

HOL/ex/term/term_rec_conv: now avoids conditional rewriting with the
premise N: List(Term(A)), since A will be uninstantiated and will cause
rewriting to fail

HOL now compiles correctly
New tar file placed on /homes/lcp

14 August

MAKE-ALL (NJ) ran perfectly.  It took 2:19 hours.
MAKE-ALL (Poly/ML) ran perfectly.  It took 2:04 hours.

18 August

NEW VERSION FROM TOBY

Provers/simp/set_auto_tac: new, installs the auto_tac.
*/simpdata: changed accordingly

Pure/types: The mechanism for typing names during instantiation has been
streamlined. The defaults and defaultsv have been replaced by a single
types_sorts.

HOL/simpdata: changed the default auto_tac to ares_tac [TrueI]

19 August

MAKE-ALL (Poly/ML) failed for HOL.

HOL/ex/arith/diffs0_imp_equal: removed an (assume_tac 1) made redundant by
the new default auto_tac, and simplified the proof

Pure/library/maketest: now prints a message to standard output
*/ex/ROOT.ML, */ex.ML: maketest(); writeln"..." simplified to maketest"..."

FOL/ex/intro,ex/prolog/ext_theory: deleted.  These now use extend_theory.

20 August

MAKE-ALL (NJ) ran perfectly.

**** Changing the treatment of flexflex pairs

A new binary relation =?=, to be synonymous with equality but used only to
represent flexflex constraints.

Pure/SYNTAX/sextension/pure_sext: added =?=

Pure/logic/is_equals,is_implies: deleted as totally unused

Pure/logic/strip_equals: renamed strip_flexpairs
Pure/logic/list_equals: renamed list_flexpairs.  These two functions now
operate on "=?=" rather than "==".

Pure/thm/flexpair: new, definition of the relation =?= 

Pure/goals/read: now calls Sign.read_cterm, which performs type-checking,
rather than Syntax.read.

21 August

MAKE-ALL (Poly/ML) ran perfectly.
New tar file placed on /homes/lcp

**** Changing the syntax of "Binder" to take a single type

Pure/SYNTAX/sextension: new version from Tobias
LK/syntax,FOL/ruleshell,CTT/syntax,HOL/ruleshell: new Binder syntax used

MAKE-ALL (Poly/ML) ran perfectly (except for running out of disc quota in
HOL)

HOL/ruleshell: deleted the spurious line
  Mixfix("(3EX! _./ _)","[IDT_LIST, bool] => bool", "@Ex1", [0,0], 10),

MAKE-ALL (Poly/ML 2.01MSX and Standard ML of New Jersey, Version 75) ran
perfectly.

README,*/README: updated

New tar file placed on /homes/lcp

