Isabelle NEWS -- history user-relevant changes

==============================================

New in Isabelle2004 (April 2004)

--------------------------------

*** General ***

* Provers/order.ML:  new efficient reasoner for partial and linear orders.

  Replaces linorder.ML.

* Pure: Greek letters (except small lambda, \<lambda>), as well as Gothic

  (\<aa>...\<zz>\<AA>...\<ZZ>), calligraphic (\<A>...\<Z>), and Euler

  (\<a>...\<z>), are now considered normal letters, and can therefore

  be used anywhere where an ASCII letter (a...zA...Z) has until

  now. COMPATIBILITY: This obviously changes the parsing of some

  terms, especially where a symbol has been used as a binder, say

  '\<Pi>x. ...', which is now a type error since \<Pi>x will be parsed

  as an identifier.  Fix it by inserting a space around former

  symbols.  Call 'isatool fixgreek' to try to fix parsing errors in

  existing theory and ML files.

* Pure: Macintosh and Windows line-breaks are now allowed in theory files.

* Pure: single letter sub/superscripts (\<^isub> and \<^isup>) are now 

  allowed in identifiers. Similar to Greek letters \<^isub> is now considered 

  a normal (but invisible) letter. For multiple letter subscripts repeat 

  \<^isub> like this: x\<^isub>1\<^isub>2. 

* Pure: There are now sub-/superscripts that can span more than one

  character. Text between \<^bsub> and \<^esub> is set in subscript in

  ProofGeneral and LaTeX, text between \<^bsup> and \<^esup> in

  superscript. The new control characters are not identifier parts.

* Pure: Control-symbols of the form \<^raw:...> will literally print the

  content of "..." to the latex file instead of \isacntrl... . The "..."

  may consist of any printable characters excluding the end bracket >.

* Pure: Using new Isar command "finalconsts" (or the ML functions

  Theory.add_finals or Theory.add_finals_i) it is now possible to

  declare constants "final", which prevents their being given a definition

  later.  It is useful for constants whose behaviour is fixed axiomatically

  rather than definitionally, such as the meta-logic connectives.

* Pure: 'instance' now handles general arities with general sorts

  (i.e. intersections of classes),

* Presentation: generated HTML now uses a CSS style sheet to make layout

  (somewhat) independent of content. It is copied from lib/html/isabelle.css. 

  It can be changed to alter the colors/layout of generated pages.

*** Isar ***

* Tactic emulation methods rule_tac, erule_tac, drule_tac, frule_tac,

  cut_tac, subgoal_tac and thin_tac:

  - Now understand static (Isar) contexts.  As a consequence, users of Isar

    locales are no longer forced to write Isar proof scripts.

    For details see Isar Reference Manual, paragraph 4.3.2: Further tactic

    emulations.

  - INCOMPATIBILITY: names of variables to be instantiated may no

    longer be enclosed in quotes.  Instead, precede variable name with `?'.

    This is consistent with the instantiation attribute "where".

* Attributes "where" and "of":

  - Now take type variables of instantiated theorem into account when reading

    the instantiation string.  This fixes a bug that caused instantiated

    theorems to have too special types in some circumstances.

  - "where" permits explicit instantiations of type variables.

* Calculation commands "moreover" and "also" no longer interfere with

  current facts ("this"), admitting arbitrary combinations with "then"

  and derived forms.

* Locales:

  - Goal statements involving the context element "includes" no longer

    generate theorems with internal delta predicates (those ending on

    "_axioms") in the premise.

    Resolve particular premise with <locale>.intro to obtain old form.

  - Fixed bug in type inference ("unify_frozen") that prevented mix of target

    specification and "includes" elements in goal statement.

  - Rule sets <locale>.intro and <locale>.axioms no longer declared as

    [intro?] and [elim?] (respectively) by default.

  - Experimental command for instantiation of locales in proof contexts:

        instantiate <label>[<attrs>]: <loc>

    Instantiates locale <loc> and adds all its theorems to the current context

    taking into account their attributes.  Label and attrs are optional

    modifiers, like in theorem declarations.  If present, names of

    instantiated theorems are qualified with <label>, and the attributes

    <attrs> are applied after any attributes these theorems might have already.

      If the locale has assumptions, a chained fact of the form

    "<loc> t1 ... tn" is expected from which instantiations of the parameters

    are derived.  The command does not support old-style locales declared

    with "locale (open)".

      A few (very simple) examples can be found in FOL/ex/LocaleInst.thy.

* HOL: Tactic emulation methods induct_tac and case_tac understand static

  (Isar) contexts.

*** HOL ***

* Simplifier:

  - Much improved handling of linear and partial orders.

    Reasoners for linear and partial orders are set up for type classes

    "linorder" and "order" respectively, and are added to the default simpset

    as solvers.  This means that the simplifier can build transitivity chains

    to solve goals from the assumptions.

  - INCOMPATIBILITY: old proofs break occasionally.  Typically, applications

    of blast or auto after simplification become unnecessary because the goal

    is solved by simplification already.

* Numerics: new theory Ring_and_Field contains over 250 basic numerical laws, 

    all proved in axiomatic type classes for semirings, rings and fields.

* Numerics:

  - Numeric types (nat, int, and in HOL-Complex rat, real, complex, etc.) are

    now formalized using the Ring_and_Field theory mentioned above. 

  - INCOMPATIBILITY: simplification and arithmetic behaves somewhat differently

    than before, because now they are set up once in a generic manner.

  - INCOMPATIBILITY: many type-specific arithmetic laws have gone. 

    Look for the general versions in Ring_and_Field (and Power if they concern

    exponentiation).

* Type "rat" of the rational numbers is now available in HOL-Complex.

* Records:

  - Record types are now by default printed with their type abbreviation

    instead of the list of all field types. This can be configured via

    the reference "print_record_type_abbr".

  - Simproc "record_upd_simproc" for simplification of multiple updates added 

    (not enabled by default).

  - Simproc "record_ex_sel_eq_simproc" to simplify EX x. sel r = x resp.

    EX x. x = sel r to True (not enabled by default).

  - Tactic "record_split_simp_tac" to split and simplify records added.

* 'specification' command added, allowing for definition by

  specification.  There is also an 'ax_specification' command that

  introduces the new constants axiomatically.

* arith(_tac) is now able to generate counterexamples for reals as well.

* HOL-Algebra: new locale "ring" for non-commutative rings.

* HOL-ex: InductiveInvariant_examples illustrates advanced recursive function

  definitions, thanks to Sava Krsti\'{c} and John Matthews.

* HOL-Matrix: a first theory for matrices in HOL with an application of 

  matrix theory to linear programming.

* Unions and Intersections:

  The x-symbol output syntax of UN and INT has been changed

  from "\<Union>x \<in> A. B" to "\<Union\<^bsub>x \<in> A\<^esub> B"

  i.e. the index formulae has become a subscript, like in normal math.

  Similarly for "\<Union>x. B", and for \<Inter> instead of \<Union>.

  The subscript version is also accepted as input syntax.

* Unions and Intersections over Intervals:

  There is new short syntax "UN i<=n. A" for "UN i:{0..n}. A". There is 

  also an x-symbol version with subscripts "\<Union>\<^bsub>i <= n\<^esub>. A" 

  like in normal math, and corresponding versions for < and for intersection.

* ML: the legacy theory structures Int and List have been removed. They had

  conflicted with ML Basis Library structures having the same names.

* 'refute' command added to search for (finite) countermodels.  Only works

  for a fragment of HOL.  The installation of an external SAT solver is

  highly recommended.  See "HOL/Refute.thy" for details.

* 'quickcheck' command: Allows to find counterexamples by evaluating

  formulae under an assignment of free variables to random values.

  In contrast to 'refute', it can deal with inductive datatypes,

  but cannot handle quantifiers. See "HOL/ex/Quickcheck_Examples.thy"

  for examples.

*** HOLCF ***

* Streams now come with concatenation and are part of the HOLCF image

New in Isabelle2003 (May 2003)

------------------------------

*** General ***

* Provers/simplifier:

  - Completely reimplemented method simp (ML: Asm_full_simp_tac):

    Assumptions are now subject to complete mutual simplification,

    not just from left to right. The simplifier now preserves

    the order of assumptions.

    Potential INCOMPATIBILITY:

    -- simp sometimes diverges where the old version did

       not, e.g. invoking simp on the goal

        [| P (f x); y = x; f x = f y |] ==> Q

       now gives rise to the infinite reduction sequence

        P(f x) --(f x = f y)--> P(f y) --(y = x)--> P(f x) --(f x = f y)--> ...

       Using "simp (asm_lr)" (ML: Asm_lr_simp_tac) instead often solves this

       kind of problem.

    -- Tactics combining classical reasoner and simplification (such as auto)

       are also affected by this change, because many of them rely on

       simp. They may sometimes diverge as well or yield a different numbers

       of subgoals. Try to use e.g. force, fastsimp, or safe instead of auto

       in case of problems. Sometimes subsequent calls to the classical

       reasoner will fail because a preceeding call to the simplifier too

       eagerly simplified the goal, e.g. deleted redundant premises.

  - The simplifier trace now shows the names of the applied rewrite rules

  - You can limit the number of recursive invocations of the simplifier

    during conditional rewriting (where the simplifie tries to solve the

    conditions before applying the rewrite rule):

    ML "simp_depth_limit := n"

    where n is an integer. Thus you can force termination where previously

    the simplifier would diverge.

  - Accepts free variables as head terms in congruence rules.  Useful in Isar.

  - No longer aborts on failed congruence proof.  Instead, the

    congruence is ignored.

* Pure: New generic framework for extracting programs from constructive

  proofs. See HOL/Extraction.thy for an example instantiation, as well

  as HOL/Extraction for some case studies.

* Pure: The main goal of the proof state is no longer shown by default, only

the subgoals. This behaviour is controlled by a new flag.

   PG menu: Isabelle/Isar -> Settings -> Show Main Goal

(ML: Proof.show_main_goal).

* Pure: You can find all matching introduction rules for subgoal 1, i.e. all

rules whose conclusion matches subgoal 1:

      PG menu: Isabelle/Isar -> Show me -> matching rules

The rules are ordered by how closely they match the subgoal.

In particular, rules that solve a subgoal outright are displayed first

(or rather last, the way they are printed).

(ML: ProofGeneral.print_intros())

* Pure: New flag trace_unify_fail causes unification to print

diagnostic information (PG: in trace buffer) when it fails. This is

useful for figuring out why single step proofs like rule, erule or

assumption failed.

* Pure: Locale specifications now produce predicate definitions

according to the body of text (covering assumptions modulo local

definitions); predicate "loc_axioms" covers newly introduced text,

while "loc" is cumulative wrt. all included locale expressions; the

latter view is presented only on export into the global theory

context; potential INCOMPATIBILITY, use "(open)" option to fall back

on the old view without predicates;

* Pure: predefined locales "var" and "struct" are useful for sharing

parameters (as in CASL, for example); just specify something like

``var x + var y + struct M'' as import;

* Pure: improved thms_containing: proper indexing of facts instead of

raw theorems; check validity of results wrt. current name space;

include local facts of proof configuration (also covers active

locales), cover fixed variables in index; may use "_" in term

specification; an optional limit for the number of printed facts may

be given (the default is 40);

* Pure: disallow duplicate fact bindings within new-style theory files

(batch-mode only);

* Provers: improved induct method: assumptions introduced by case

"foo" are split into "foo.hyps" (from the rule) and "foo.prems" (from

the goal statement); "foo" still refers to all facts collectively;

* Provers: the function blast.overloaded has been removed: all constants

are regarded as potentially overloaded, which improves robustness in exchange

for slight decrease in efficiency;

* Provers/linorder: New generic prover for transitivity reasoning over

linear orders.  Note: this prover is not efficient!

* Isar: preview of problems to finish 'show' now produce an error

rather than just a warning (in interactive mode);

*** HOL ***

* arith(_tac)

 - Produces a counter example if it cannot prove a goal.

   Note that the counter example may be spurious if the goal is not a formula

   of quantifier-free linear arithmetic.

   In ProofGeneral the counter example appears in the trace buffer.

 - Knows about div k and mod k where k is a numeral of type nat or int.

 - Calls full Presburger arithmetic (by Amine Chaieb) if quantifier-free

   linear arithmetic fails. This takes account of quantifiers and divisibility.

   Presburger arithmetic can also be called explicitly via presburger(_tac). 

* simp's arithmetic capabilities have been enhanced a bit: it now

takes ~= in premises into account (by performing a case split);

* simp reduces "m*(n div m) + n mod m" to n, even if the two summands

are distributed over a sum of terms;

* New tactic "trans_tac" and method "trans" instantiate

Provers/linorder.ML for axclasses "order" and "linorder" (predicates

"<=", "<" and "="). 

* function INCOMPATIBILITIES: Pi-sets have been redefined and moved from main 

HOL to Library/FuncSet; constant "Fun.op o" is now called "Fun.comp";

* 'typedef' command has new option "open" to suppress the set

definition;

* functions Min and Max on finite sets have been introduced (theory

Finite_Set);

* attribute [symmetric] now works for relations as well; it turns

(x,y) : R^-1 into (y,x) : R, and vice versa;

* induct over a !!-quantified statement (say !!x1..xn):

  each "case" automatically performs "fix x1 .. xn" with exactly those names.

* Map: `empty' is no longer a constant but a syntactic abbreviation for

%x. None. Warning: empty_def now refers to the previously hidden definition

of the empty set.

* Algebra: formalization of classical algebra.  Intended as base for

any algebraic development in Isabelle.  Currently covers group theory

(up to Sylow's theorem) and ring theory (Universal Property of

Univariate Polynomials).  Contributions welcome;

* GroupTheory: deleted, since its material has been moved to Algebra;

* Complex: new directory of the complex numbers with numeric constants, 

nonstandard complex numbers, and some complex analysis, standard and 

nonstandard (Jacques Fleuriot);

* HOL-Complex: new image for analysis, replacing HOL-Real and HOL-Hyperreal;

* Hyperreal: introduced Gauge integration and hyperreal logarithms (Jacques 

Fleuriot);

* Real/HahnBanach: updated and adapted to locales;

* NumberTheory: added Gauss's law of quadratic reciprocity (by Avigad,

Gray and Kramer);

* UNITY: added the Meier-Sanders theory of progress sets;

* MicroJava: bytecode verifier and lightweight bytecode verifier

as abstract algorithms, instantiated to the JVM;

* Bali: Java source language formalization. Type system, operational

semantics, axiomatic semantics. Supported language features:

classes, interfaces, objects,virtual methods, static methods,

static/instance fields, arrays, access modifiers, definite

assignment, exceptions.

*** ZF ***

* ZF/Constructible: consistency proof for AC (Gödel's constructible

universe, etc.);

* Main ZF: virtually all theories converted to new-style format;

*** ML ***

* Pure: Tactic.prove provides sane interface for internal proofs;

omits the infamous "standard" operation, so this is more appropriate

than prove_goalw_cterm in many situations (e.g. in simprocs);

* Pure: improved error reporting of simprocs;

* Provers: Simplifier.simproc(_i) provides sane interface for setting

up simprocs;

*** Document preparation ***

* uses \par instead of \\ for line breaks in theory text. This may

shift some page breaks in large documents. To get the old behaviour

use \renewcommand{\isanewline}{\mbox{}\\\mbox{}} in root.tex.

* minimized dependencies of isabelle.sty and isabellesym.sty on 

other packages

* \<euro> now needs package babel/greek instead of marvosym (which

broke \Rightarrow)

* normal size for \<zero>...\<nine> (uses \mathbf instead of 

textcomp package)

New in Isabelle2002 (March 2002)

--------------------------------

*** Document preparation ***

* greatly simplified document preparation setup, including more

graceful interpretation of isatool usedir -i/-d/-D options, and more

instructive isatool mkdir; users should basically be able to get

started with "isatool mkdir HOL Test && isatool make"; alternatively,

users may run a separate document processing stage manually like this:

"isatool usedir -D output HOL Test && isatool document Test/output";

* theory dependency graph may now be incorporated into documents;

isatool usedir -g true will produce session_graph.eps/.pdf for use

with \includegraphics of LaTeX;

* proper spacing of consecutive markup elements, especially text

blocks after section headings;

* support bold style (for single symbols only), input syntax is like

this: "\<^bold>\<alpha>" or "\<^bold>A";

* \<bullet> is now output as bold \cdot by default, which looks much

better in printed text;

* added default LaTeX bindings for \<tturnstile> and \<TTurnstile>;

note that these symbols are currently unavailable in Proof General /

X-Symbol; new symbols \<zero>, \<one>, ..., \<nine>, and \<euro>;

* isatool latex no longer depends on changed TEXINPUTS, instead

isatool document copies the Isabelle style files to the target

location;

*** Isar ***

* Pure/Provers: improved proof by cases and induction;

  - 'case' command admits impromptu naming of parameters (such as

    "case (Suc n)");

  - 'induct' method divinates rule instantiation from the inductive

    claim; no longer requires excessive ?P bindings for proper

    instantiation of cases;

  - 'induct' method properly enumerates all possibilities of set/type

    rules; as a consequence facts may be also passed through *type*

    rules without further ado;

  - 'induct' method now derives symbolic cases from the *rulified*

    rule (before it used to rulify cases stemming from the internal

    atomized version); this means that the context of a non-atomic

    statement becomes is included in the hypothesis, avoiding the

    slightly cumbersome show "PROP ?case" form;

  - 'induct' may now use elim-style induction rules without chaining

    facts, using ``missing'' premises from the goal state; this allows

    rules stemming from inductive sets to be applied in unstructured

    scripts, while still benefitting from proper handling of non-atomic

    statements; NB: major inductive premises need to be put first, all

    the rest of the goal is passed through the induction;

  - 'induct' proper support for mutual induction involving non-atomic

    rule statements (uses the new concept of simultaneous goals, see

    below);

  - append all possible rule selections, but only use the first

    success (no backtracking);

  - removed obsolete "(simplified)" and "(stripped)" options of methods;

  - undeclared rule case names default to numbers 1, 2, 3, ...;

  - added 'print_induct_rules' (covered by help item in recent Proof

    General versions);

  - moved induct/cases attributes to Pure, methods to Provers;

  - generic method setup instantiated for FOL and HOL;

* Pure: support multiple simultaneous goal statements, for example

"have a: A and b: B" (same for 'theorem' etc.); being a pure

meta-level mechanism, this acts as if several individual goals had

been stated separately; in particular common proof methods need to be

repeated in order to cover all claims; note that a single elimination

step is *not* sufficient to establish the two conjunctions, so this

fails:

  assume "A & B" then have A and B ..   (*".." fails*)

better use "obtain" in situations as above; alternative refer to

multi-step methods like 'auto', 'simp_all', 'blast+' etc.;

* Pure: proper integration with ``locales''; unlike the original

version by Florian Kammüller, Isar locales package high-level proof

contexts rather than raw logical ones (e.g. we admit to include

attributes everywhere); operations on locales include merge and

rename; support for implicit arguments (``structures''); simultaneous

type-inference over imports and text; see also HOL/ex/Locales.thy for

some examples;

* Pure: the following commands have been ``localized'', supporting a

target locale specification "(in name)": 'lemma', 'theorem',

'corollary', 'lemmas', 'theorems', 'declare'; the results will be

stored both within the locale and at the theory level (exported and

qualified by the locale name);

* Pure: theory goals may now be specified in ``long'' form, with

ad-hoc contexts consisting of arbitrary locale elements. for example

``lemma foo: fixes x assumes "A x" shows "B x"'' (local syntax and

definitions may be given, too); the result is a meta-level rule with

the context elements being discharged in the obvious way;

* Pure: new proof command 'using' allows to augment currently used

facts after a goal statement ('using' is syntactically analogous to

'apply', but acts on the goal's facts only); this allows chained facts

to be separated into parts given before and after a claim, as in

``from a and b have C using d and e <proof>'';

* Pure: renamed "antecedent" case to "rule_context";

* Pure: new 'judgment' command records explicit information about the

object-logic embedding (used by several tools internally); no longer

use hard-wired "Trueprop";

* Pure: added 'corollary' command;

* Pure: fixed 'token_translation' command;

* Pure: removed obsolete 'exported' attribute;

* Pure: dummy pattern "_" in is/let is now automatically lifted over

bound variables: "ALL x. P x --> Q x" (is "ALL x. _ --> ?C x")

supersedes more cumbersome ... (is "ALL x. _ x --> ?C x");

* Pure: method 'atomize' presents local goal premises as object-level

statements (atomic meta-level propositions); setup controlled via

rewrite rules declarations of 'atomize' attribute; example

application: 'induct' method with proper rule statements in improper

proof *scripts*;

* Pure: emulation of instantiation tactics (rule_tac, cut_tac, etc.)

now consider the syntactic context of assumptions, giving a better

chance to get type-inference of the arguments right (this is

especially important for locales);

* Pure: "sorry" no longer requires quick_and_dirty in interactive

mode;

* Pure/obtain: the formal conclusion "thesis", being marked as

``internal'', may no longer be reference directly in the text;

potential INCOMPATIBILITY, may need to use "?thesis" in rare

situations;

* Pure: generic 'sym' attribute which declares a rule both as pure

'elim?' and for the 'symmetric' operation;

* Pure: marginal comments ``--'' may now occur just anywhere in the

text; the fixed correlation with particular command syntax has been

discontinued;

* Pure: new method 'rules' is particularly well-suited for proof

search in intuitionistic logic; a bit slower than 'blast' or 'fast',

but often produces more compact proof terms with less detours;

* Pure/Provers/classical: simplified integration with pure rule

attributes and methods; the classical "intro?/elim?/dest?"

declarations coincide with the pure ones; the "rule" method no longer

includes classically swapped intros; "intro" and "elim" methods no

longer pick rules from the context; also got rid of ML declarations

AddXIs/AddXEs/AddXDs; all of this has some potential for

INCOMPATIBILITY;

* Provers/classical: attribute 'swapped' produces classical inversions

of introduction rules;

* Provers/simplifier: 'simplified' attribute may refer to explicit

rules instead of full simplifier context; 'iff' attribute handles

conditional rules;

* HOL: 'typedef' now allows alternative names for Rep/Abs morphisms;

* HOL: 'recdef' now fails on unfinished automated proofs, use

"(permissive)" option to recover old behavior;

* HOL: 'inductive' no longer features separate (collective) attributes

for 'intros' (was found too confusing);

* HOL: properly declared induction rules less_induct and

wf_induct_rule;

*** HOL ***

* HOL: moved over to sane numeral syntax; the new policy is as

follows:

  - 0 and 1 are polymorphic constants, which are defined on any

  numeric type (nat, int, real etc.);

  - 2, 3, 4, ... and -1, -2, -3, ... are polymorphic numerals, based

  binary representation internally;

  - type nat has special constructor Suc, and generally prefers Suc 0

  over 1::nat and Suc (Suc 0) over 2::nat;

This change may cause significant problems of INCOMPATIBILITY; here

are some hints on converting existing sources:

  - due to the new "num" token, "-0" and "-1" etc. are now atomic

  entities, so expressions involving "-" (unary or binary minus) need

  to be spaced properly;

  - existing occurrences of "1" may need to be constraint "1::nat" or

  even replaced by Suc 0; similar for old "2";

  - replace "#nnn" by "nnn", and "#-nnn" by "-nnn";

  - remove all special provisions on numerals in proofs;

* HOL: simp rules nat_number expand numerals on nat to Suc/0

representation (depends on bin_arith_simps in the default context);

* HOL: symbolic syntax for x^2 (numeral 2);

* HOL: the class of all HOL types is now called "type" rather than

"term"; INCOMPATIBILITY, need to adapt references to this type class

in axclass/classes, instance/arities, and (usually rare) occurrences

in typings (of consts etc.); internally the class is called

"HOL.type", ML programs should refer to HOLogic.typeS;

* HOL/record package improvements:

  - new derived operations "fields" to build a partial record section,

    "extend" to promote a fixed record to a record scheme, and

    "truncate" for the reverse; cf. theorems "xxx.defs", which are *not*

    declared as simp by default;

  - shared operations ("more", "fields", etc.) now need to be always

    qualified) --- potential INCOMPATIBILITY;

  - removed "make_scheme" operations (use "make" with "extend") --

    INCOMPATIBILITY;

  - removed "more" class (simply use "term") -- INCOMPATIBILITY;

  - provides cases/induct rules for use with corresponding Isar

    methods (for concrete records, record schemes, concrete more

    parts, and schematic more parts -- in that order);

  - internal definitions directly based on a light-weight abstract

    theory of product types over typedef rather than datatype;

* HOL: generic code generator for generating executable ML code from

specifications; specific support for HOL constructs such as inductive

datatypes and sets, as well as recursive functions; can be invoked

via 'generate_code' theory section;

* HOL: canonical cases/induct rules for n-tuples (n = 3..7);

* HOL: consolidated and renamed several theories.  In particular:

	Ord.thy has been absorbed into HOL.thy

	String.thy has been absorbed into List.thy

* HOL: concrete setsum syntax "\<Sum>i:A. b" == "setsum (%i. b) A"

(beware of argument permutation!);

* HOL: linorder_less_split superseded by linorder_cases;

* HOL/List: "nodups" renamed to "distinct";

* HOL: added "The" definite description operator; move Hilbert's "Eps"

to peripheral theory "Hilbert_Choice"; some INCOMPATIBILITIES:

  - Ex_def has changed, now need to use some_eq_ex

* HOL: made split_all_tac safe; EXISTING PROOFS MAY FAIL OR LOOP, so

in this (rare) case use:

  delSWrapper "split_all_tac"

  addSbefore ("unsafe_split_all_tac", unsafe_split_all_tac)

* HOL: added safe wrapper "split_conv_tac" to claset; EXISTING PROOFS

MAY FAIL;

* HOL: introduced f^n = f o ... o f; warning: due to the limits of

Isabelle's type classes, ^ on functions and relations has too general

a domain, namely ('a * 'b) set and 'a => 'b; this means that it may be

necessary to attach explicit type constraints;

* HOL/Relation: the prefix name of the infix "O" has been changed from

"comp" to "rel_comp"; INCOMPATIBILITY: a few theorems have been

renamed accordingly (eg "compI" -> "rel_compI").

* HOL: syntax translations now work properly with numerals and records

expressions;

* HOL: bounded abstraction now uses syntax "%" / "\<lambda>" instead

of "lam" -- INCOMPATIBILITY;

* HOL: got rid of some global declarations (potential INCOMPATIBILITY

for ML tools): const "()" renamed "Product_Type.Unity", type "unit"

renamed "Product_Type.unit";

* HOL: renamed rtrancl_into_rtrancl2 to converse_rtrancl_into_rtrancl

* HOL: removed obsolete theorem "optionE" (use "option.exhaust", or

the "cases" method);

* HOL/GroupTheory: group theory examples including Sylow's theorem (by

Florian Kammüller);

* HOL/IMP: updated and converted to new-style theory format; several

parts turned into readable document, with proper Isar proof texts and

some explanations (by Gerwin Klein);

* HOL-Real: added Complex_Numbers (by Gertrud Bauer);

* HOL-Hyperreal is now a logic image;

*** HOLCF ***

* Isar: consts/constdefs supports mixfix syntax for continuous

operations;

* Isar: domain package adapted to new-style theory format, e.g. see

HOLCF/ex/Dnat.thy;

* theory Lift: proper use of rep_datatype lift instead of ML hacks --

potential INCOMPATIBILITY; now use plain induct_tac instead of former

lift.induct_tac, always use UU instead of Undef;

* HOLCF/IMP: updated and converted to new-style theory;

*** ZF ***

* Isar: proper integration of logic-specific tools and packages,

including theory commands '(co)inductive', '(co)datatype',

'rep_datatype', 'inductive_cases', as well as methods 'ind_cases',

'induct_tac', 'case_tac', and 'typecheck' (with attribute 'TC');

* theory Main no longer includes AC; for the Axiom of Choice, base

your theory on Main_ZFC;

* the integer library now covers quotients and remainders, with many

laws relating division to addition, multiplication, etc.;

* ZF/UNITY: Chandy and Misra's UNITY is now available in ZF, giving a

typeless version of the formalism;

* ZF/AC, Coind, IMP, Resid: updated and converted to new-style theory

format;

* ZF/Induct: new directory for examples of inductive definitions,

including theory Multiset for multiset orderings; converted to

new-style theory format;

* ZF: many new theorems about lists, ordinals, etc.;

*** General ***

* Pure/kernel: meta-level proof terms (by Stefan Berghofer); reference

variable proof controls level of detail: 0 = no proofs (only oracle

dependencies), 1 = lemma dependencies, 2 = compact proof terms; see

also ref manual for further ML interfaces;

* Pure/axclass: removed obsolete ML interface

goal_subclass/goal_arity;

* Pure/syntax: new token syntax "num" for plain numerals (without "#"

of "xnum"); potential INCOMPATIBILITY, since -0, -1 etc. are now

separate tokens, so expressions involving minus need to be spaced

properly;

* Pure/syntax: support non-oriented infixes, using keyword "infix"

rather than "infixl" or "infixr";

* Pure/syntax: concrete syntax for dummy type variables admits genuine

sort constraint specifications in type inference; e.g. "x::_::foo"

ensures that the type of "x" is of sort "foo" (but not necessarily a

type variable);

* Pure/syntax: print modes "type_brackets" and "no_type_brackets"

control output of nested => (types); the default behavior is

"type_brackets";

* Pure/syntax: builtin parse translation for "_constify" turns valued

tokens into AST constants;

* Pure/syntax: prefer later declarations of translations and print

translation functions; potential INCOMPATIBILITY: need to reverse

multiple declarations for same syntax element constant;

* Pure/show_hyps reset by default (in accordance to existing Isar

practice);

* Provers/classical: renamed addaltern to addafter, addSaltern to

addSafter;

* Provers/clasimp: ``iff'' declarations now handle conditional rules

as well;

* system: tested support for MacOS X; should be able to get Isabelle +

Proof General to work in a plain Terminal after installing Poly/ML

(e.g. from the Isabelle distribution area) and GNU bash alone

(e.g. from http://www.apple.com); full X11, XEmacs and X-Symbol

support requires further installations, e.g. from

http://fink.sourceforge.net/);

* system: support Poly/ML 4.1.1 (able to manage larger heaps);

* system: reduced base memory usage by Poly/ML (approx. 20 MB instead

of 40 MB), cf. ML_OPTIONS;

* system: Proof General keywords specification is now part of the

Isabelle distribution (see etc/isar-keywords.el);

* system: support for persistent Proof General sessions (refrain from

outdating all loaded theories on startup); user may create writable

logic images like this: ``isabelle -q HOL Test'';

* system: smart selection of Isabelle process versus Isabelle

interface, accommodates case-insensitive file systems (e.g. HFS+); may

run both "isabelle" and "Isabelle" even if file names are badly

damaged (executable inspects the case of the first letter of its own

name); added separate "isabelle-process" and "isabelle-interface";

* system: refrain from any attempt at filtering input streams; no

longer support ``8bit'' encoding of old isabelle font, instead proper

iso-latin characters may now be used; the related isatools

"symbolinput" and "nonascii" have disappeared as well;

* system: removed old "xterm" interface (the print modes "xterm" and

"xterm_color" are still available for direct use in a suitable

terminal);

New in Isabelle99-2 (February 2001)

-----------------------------------

*** Overview of INCOMPATIBILITIES ***

* HOL: please note that theories in the Library and elsewhere often use the

new-style (Isar) format; to refer to their theorems in an ML script you must

bind them to ML identifers by e.g.      val thm_name = thm "thm_name";

* HOL: inductive package no longer splits induction rule aggressively,

but only as far as specified by the introductions given; the old

format may be recovered via ML function complete_split_rule or attribute

'split_rule (complete)';

* HOL: induct renamed to lfp_induct, lfp_Tarski to lfp_unfold,

gfp_Tarski to gfp_unfold;

* HOL: contrapos, contrapos2 renamed to contrapos_nn, contrapos_pp;

* HOL: infix "dvd" now has priority 50 rather than 70 (because it is a

relation); infix "^^" has been renamed "``"; infix "``" has been

renamed "`"; "univalent" has been renamed "single_valued";

* HOL/Real: "rinv" and "hrinv" replaced by overloaded "inverse"

operation;

* HOLCF: infix "`" has been renamed "$"; the symbol syntax is \<cdot>;

* Isar: 'obtain' no longer declares "that" fact as simp/intro;

* Isar/HOL: method 'induct' now handles non-atomic goals; as a

consequence, it is no longer monotonic wrt. the local goal context

(which is now passed through the inductive cases);

* Document preparation: renamed standard symbols \<ll> to \<lless> and

\<gg> to \<ggreater>;

*** Document preparation ***

* \isabellestyle{NAME} selects version of Isabelle output (currently

available: are "it" for near math-mode best-style output, "sl" for

slanted text style, and "tt" for plain type-writer; if no

\isabellestyle command is given, output is according to slanted

type-writer);

* support sub/super scripts (for single symbols only), input syntax is

like this: "A\<^sup>*" or "A\<^sup>\<star>";

* some more standard symbols; see Appendix A of the system manual for

the complete list of symbols defined in isabellesym.sty;

* improved isabelle style files; more abstract symbol implementation

(should now use \isamath{...} and \isatext{...} in custom symbol

definitions);

* antiquotation @{goals} and @{subgoals} for output of *dynamic* goals

state; Note that presentation of goal states does not conform to

actual human-readable proof documents.  Please do not include goal

states into document output unless you really know what you are doing!

* proper indentation of antiquoted output with proportional LaTeX

fonts;

* no_document ML operator temporarily disables LaTeX document

generation;

* isatool unsymbolize tunes sources for plain ASCII communication;

*** Isar ***

* Pure: Isar now suffers initial goal statements to contain unbound

schematic variables (this does not conform to actual readable proof

documents, due to unpredictable outcome and non-compositional proof

checking); users who know what they are doing may use schematic goals

for Prolog-style synthesis of proven results;

* Pure: assumption method (an implicit finishing) now handles actual

rules as well;

* Pure: improved 'obtain' --- moved to Pure, insert "that" into

initial goal, declare "that" only as Pure intro (only for single

steps); the "that" rule assumption may now be involved in implicit

finishing, thus ".." becomes a feasible for trivial obtains;

* Pure: default proof step now includes 'intro_classes'; thus trivial

instance proofs may be performed by "..";

* Pure: ?thesis / ?this / "..." now work for pure meta-level

statements as well;

* Pure: more robust selection of calculational rules;

* Pure: the builtin notion of 'finished' goal now includes the ==-refl

rule (as well as the assumption rule);

* Pure: 'thm_deps' command visualizes dependencies of theorems and

lemmas, using the graph browser tool;

* Pure: predict failure of "show" in interactive mode;

* Pure: 'thms_containing' now takes actual terms as arguments;

* HOL: improved method 'induct' --- now handles non-atomic goals

(potential INCOMPATIBILITY); tuned error handling;

* HOL: cases and induct rules now provide explicit hints about the

number of facts to be consumed (0 for "type" and 1 for "set" rules);

any remaining facts are inserted into the goal verbatim;

* HOL: local contexts (aka cases) may now contain term bindings as

well; the 'cases' and 'induct' methods new provide a ?case binding for

the result to be shown in each case;

* HOL: added 'recdef_tc' command;

* isatool convert assists in eliminating legacy ML scripts;

*** HOL ***

* HOL/Library: a collection of generic theories to be used together

with main HOL; the theory loader path already includes this directory

by default; the following existing theories have been moved here:

HOL/Induct/Multiset, HOL/Induct/Acc (as Accessible_Part), HOL/While

(as While_Combinator), HOL/Lex/Prefix (as List_Prefix);

* HOL/Unix: "Some aspects of Unix file-system security", a typical

modelling and verification task performed in Isabelle/HOL +

Isabelle/Isar + Isabelle document preparation (by Markus Wenzel).

* HOL/Algebra: special summation operator SUM no longer exists, it has

been replaced by setsum; infix 'assoc' now has priority 50 (like

'dvd'); axiom 'one_not_zero' has been moved from axclass 'ring' to

'domain', this makes the theory consistent with mathematical

literature;

* HOL basics: added overloaded operations "inverse" and "divide"

(infix "/"), syntax for generic "abs" operation, generic summation

operator \<Sum>;

* HOL/typedef: simplified package, provide more useful rules (see also

HOL/subset.thy);

* HOL/datatype: induction rule for arbitrarily branching datatypes is

now expressed as a proper nested rule (old-style tactic scripts may

require atomize_strip_tac to cope with non-atomic premises);

* HOL: renamed theory "Prod" to "Product_Type", renamed "split" rule

to "split_conv" (old name still available for compatibility);

* HOL: improved concrete syntax for strings (e.g. allows translation

rules with string literals);

* HOL-Real-Hyperreal: this extends HOL-Real with the hyperreals

 and Fleuriot's mechanization of analysis, including the transcendental

 functions for the reals;

* HOL/Real, HOL/Hyperreal: improved arithmetic simplification;

*** CTT ***

* CTT: x-symbol support for Pi, Sigma, -->, : (membership); note that

"lam" is displayed as TWO lambda-symbols

* CTT: theory Main now available, containing everything (that is, Bool