Isabelle NEWS -- history user-relevant changes

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

New in this Isabelle release

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

*** General ***

* Theory headers: the new header syntax for Isar theories is

  theory <name>

  imports <theory1> ... <theoryN>

  uses <file1> ... <fileM>

  begin

where the 'uses' part is optional.  The previous syntax

  theory <name> = <theory1> + ... + <theoryN>:

will disappear in the next release.  Note that there is no change in

ancient non-Isar theories.

* Theory loader: parent theories can now also be referred to via

relative and absolute paths.

* Improved version of thms_containing searches for a list of criteria

instead of a list of constants. Known criteria are: intro, elim, dest,

name:string, simp:term, and any term. Criteria can be preceded by '-'

to select theorems that do not match. Intro, elim, dest select

theorems that match the current goal, name:s selects theorems whose

fully qualified name contain s, and simp:term selects all

simplification rules whose lhs match term.  Any other term is

interpreted as pattern and selects all theorems matching the

pattern. Available in ProofGeneral under 'ProofGeneral -> Find

Theorems' or C-c C-f.  Example:

  C-c C-f (100) "(_::nat) + _ + _" intro -name:"HOL."

prints the last 100 theorems matching the pattern "(_::nat) + _ + _",

matching the current goal as introduction rule and not having "HOL."

in their name (i.e. not being defined in theory HOL).

*** Document preparation ***

* Commands 'display_drafts' and 'print_drafts' perform simple output

of raw sources.  Only those symbols that do not require additional

LaTeX packages (depending on comments in isabellesym.sty) are

displayed properly, everything else is left verbatim.  isatool display

and isatool print are used as front ends (these are subject to the

DVI/PDF_VIEWER and PRINT_COMMAND settings, respectively).

* There is now a flag to control hiding of proofs and some other

commands (such as 'ML' or 'parse/print_translation') in document

output.  Hiding is enabled by default, and can be disabled by the

option '-H false' of isatool usedir or by resetting the reference

variable IsarOutput.hide_commands in ML.  Additional commands to be

hidden may be declared using IsarOutput.add_hidden_commands.

* Several new antiquotation:

  @{term_type term} prints a term with its type annotated;

  @{typeof term} prints the type of a term;

  @{const const} is the same as @{term const}, but checks that the

  argument is a known logical constant;

  @{term_style style term} and @{thm_style style thm} print a term or

  theorem applying a "style" to it

Predefined styles are 'lhs' and 'rhs' printing the lhs/rhs of

definitions, equations, inequations etc., 'concl' printing only the

conclusion of a meta-logical statement theorem, and 'prem1' .. 'prem9'

to print the specified premise.  TermStyle.add_style provides an ML

interface for introducing further styles.  See also the "LaTeX Sugar"

document practical applications.

*** Pure ***

* Considerably improved version of 'constdefs' command.  Now performs

automatic type-inference of declared constants; additional support for

local structure declarations (cf. locales and HOL records), see also

isar-ref manual.  Potential INCOMPATIBILITY: need to observe strictly

sequential dependencies of definitions within a single 'constdefs'

section; moreover, the declared name needs to be an identifier.  If

all fails, consider to fall back on 'consts' and 'defs' separately.

* Improved indexed syntax and implicit structures.  First of all,

indexed syntax provides a notational device for subscripted

application, using the new syntax \<^bsub>term\<^esub> for arbitrary

expressions.  Secondly, in a local context with structure

declarations, number indexes \<^sub>n or the empty index (default

number 1) refer to a certain fixed variable implicitly; option

show_structs controls printing of implicit structures.  Typical

applications of these concepts involve record types and locales.

* New command 'no_syntax' removes grammar declarations (and

translations) resulting from the given syntax specification, which is

interpreted in the same manner as for the 'syntax' command.

* 'Advanced' translation functions (parse_translation etc.) may depend

on the signature of the theory context being presently used for

parsing/printing, see also isar-ref manual.

* Improved internal renaming of symbolic identifiers -- attach primes

instead of base 26 numbers.

* New flag show_question_marks controls printing of leading question

marks in schematic variable names.

* In schematic variable names, *any* symbol following \<^isub> or

\<^isup> is now treated as part of the base name.  For example, the

following works without printing of awkward ".0" indexes:

  lemma "x\<^isub>1 = x\<^isub>2 ==> x\<^isub>2 = x\<^isub>1"

    by simp

* Inner syntax includes (*(*nested*) comments*).

* Pretty pinter now supports unbreakable blocks, specified in mixfix

annotations as "(00...)".

* Clear separation of logical types and nonterminals, where the latter

may only occur in 'syntax' specifications or type abbreviations.

Before that distinction was only partially implemented via type class

"logic" vs. "{}".  Potential INCOMPATIBILITY in rare cases of improper

use of 'types'/'consts' instead of 'nonterminals'/'syntax'.  Some very

exotic syntax specifications may require further adaption

(e.g. Cube/Base.thy).

* Removed obsolete type class "logic", use the top sort {} instead.

Note that non-logical types should be declared as 'nonterminals'

rather than 'types'.  INCOMPATIBILITY for new object-logic

specifications.

* Simplifier: can now control the depth to which conditional rewriting

is traced via the PG menu Isabelle -> Settings -> Trace Simp Depth

Limit.

* Simplifier: simplification procedures may now take the current

simpset into account (cf. Simplifier.simproc(_i) / mk_simproc

interface), which is very useful for calling the Simplifier

recursively.  Minor INCOMPATIBILITY: the 'prems' argument of simprocs

is gone -- use prems_of_ss on the simpset instead.  Moreover, the

low-level mk_simproc no longer applies Logic.varify internally, to

allow for use in a context of fixed variables.

* thin_tac now works even if the assumption being deleted contains !!

or ==>.  More generally, erule now works even if the major premise of

the elimination rule contains !! or ==>.

* Reorganized bootstrapping of the Pure theories; CPure is now derived

from Pure, which contains all common declarations already.  Both

theories are defined via plain Isabelle/Isar .thy files.

INCOMPATIBILITY: elements of CPure (such as the CPure.intro /

CPure.elim / CPure.dest attributes) now appear in the Pure name space;

use isatool fixcpure to adapt your theory and ML sources.

* New syntax 'name(i-j, i-, i, ...)' for referring to specific

selections of theorems in named facts via index ranges.

*** Locales ***

* New commands for the interpretation of locale expressions in

theories ('interpretation') and proof contexts ('interpret').  These

take an instantiation of the locale parameters and compute proof

obligations from the instantiated specification.  After the

obligations have been discharged, the instantiated theorems of the

locale are added to the theory or proof context.  Interpretation is

smart in that already active interpretations do not occur in proof

obligations, neither are instantiated theorems stored in duplicate.

Use print_interps to inspect active interpretations of a particular

locale.  For details, see the Isar Reference manual.

INCOMPATIBILITY: former 'instantiate' has been withdrawn, use

'interpret' instead.

* Proper static binding of attribute syntax -- i.e. types / terms /

facts mentioned as arguments are always those of the locale definition

context, independently of the context of later invocations.  Moreover,

locale operations (renaming and type / term instantiation) are applied

to attribute arguments as expected.

INCOMPATIBILITY of the ML interface: always pass Attrib.src instead of

actual attributes; rare situations may require Attrib.attribute to

embed those attributes into Attrib.src that lack concrete syntax.

Attribute implementations need to cooperate properly with the static

binding mechanism.  Basic parsers Args.XXX_typ/term/prop and

Attrib.XXX_thm etc. already do the right thing without further

intervention.  Only unusual applications -- such as "where" or "of"

(cf. src/Pure/Isar/attrib.ML), which process arguments depending both

on the context and the facts involved -- may have to assign parsed

values to argument tokens explicitly.

* New context element "constrains" adds type constraints to parameters --

there is no logical significance.

* Context expressions: renaming parameters permits syntax

redeclaration as well.

* Locale definition: 'includes' now disallowed.

* Changed parameter management in theorem generation for long goal

statements with 'includes'.  INCOMPATIBILITY: produces a different

theorem statement in rare situations.

* Attributes 'induct' and 'cases': type or set names may now be

locally fixed variables as well.

* Antiquotations now provide the option 'locale=NAME' to specify an

alternative context used for evaluating and printing the subsequent

argument, as in @{thm [locale=LC] fold_commute}, for example.

*** Provers ***

* Provers/hypsubst.ML: improved version of the subst method, for

single-step rewriting: it now works in bound variable contexts. New is

'subst (asm)', for rewriting an assumption.  INCOMPATIBILITY: may

rewrite a different subterm than the original subst method, which is

still available as 'simplesubst'.

* Provers/quasi.ML: new transitivity reasoners for transitivity only

and quasi orders.

* Provers/trancl.ML: new transitivity reasoner for transitive and

reflexive-transitive closure of relations.

* Provers/blast.ML: new reference depth_limit to make blast's depth

limit (previously hard-coded with a value of 20) user-definable.

* Provers/simplifier.ML has been moved to Pure, where Simplifier.setup

is peformed already.  Object-logics merely need to finish their

initial simpset configuration as before.  INCOMPATIBILITY.

*** HOL ***

* Symbolic syntax of Hilbert Choice Operator is now as follows:

  syntax (epsilon)

    "_Eps" :: "[pttrn, bool] => 'a"    ("(3\<some>_./ _)" [0, 10] 10)

The symbol \<some> is displayed as the alternative epsilon of LaTeX

and x-symbol; use option '-m epsilon' to get it actually printed.

Moreover, the mathematically important symbolic identifier \<epsilon>

becomes available as variable, constant etc.  INCOMPATIBILITY,

* "x > y" abbreviates "y < x" and "x >= y" abbreviates "y <= x".

Similarly for all quantifiers: "ALL x > y" etc.  The x-symbol for >=

is \<ge>.

* "{x:A. P}" abbreviates "{x. x:A & P}", and similarly for "\<in>"

instead of ":".

* theory SetInterval: changed the syntax for open intervals:

  Old       New

  {..n(}    {..<n}

  {)n..}    {n<..}

  {m..n(}   {m..<n}

  {)m..n}   {m<..n}

  {)m..n(}  {m<..<n}

The old syntax is still supported but will disappear in the next

release.  For conversion use the following Emacs search and replace

patterns (these are not perfect but work quite well):

  {)\([^\.]*\)\.\.  ->  {\1<\.\.}

  \.\.\([^(}]*\)(}  ->  \.\.<\1}

* theory Finite_Set: changed the syntax for 'setsum', summation over

finite sets: "setsum (%x. e) A", which used to be "\<Sum>x:A. e", is

now either "SUM x:A. e" or "\<Sum>x \<in> A. e".

Some new syntax forms are available:

  "\<Sum>x | P. e"      for     "setsum (%x. e) {x. P}"

  "\<Sum>x = a..b. e"   for     "setsum (%x. e) {a..b}"

  "\<Sum>x = a..<b. e"  for     "setsum (%x. e) {a..<b}"

  "\<Sum>x < k. e"      for     "setsum (%x. e) {..<k}"

The latter form "\<Sum>x < k. e" used to be based on a separate

function "Summation", which has been discontinued.

* theory Finite_Set: in structured induction proofs, the insert case

is now 'case (insert x F)' instead of the old counterintuitive 'case

(insert F x)'.

* The 'refute' command has been extended to support a much larger

fragment of HOL, including axiomatic type classes, constdefs and

typedefs, inductive datatypes and recursion.

* Datatype induction via method 'induct' now preserves the name of the

induction variable. For example, when proving P(xs::'a list) by

induction on xs, the induction step is now P(xs) ==> P(a#xs) rather

than P(list) ==> P(a#list) as previously.  Potential INCOMPATIBILITY

in unstructured proof scripts.

* Reworked implementation of records.  Improved scalability for

records with many fields, avoiding performance problems for type

inference. Records are no longer composed of nested field types, but

of nested extension types. Therefore the record type only grows linear

in the number of extensions and not in the number of fields.  The

top-level (users) view on records is preserved.  Potential

INCOMPATIBILITY only in strange cases, where the theory depends on the

old record representation. The type generated for a record is called

<record_name>_ext_type.

Flag record_quick_and_dirty_sensitive can be enabled to skip the

proofs triggered by a record definition or a simproc (if

quick_and_dirty is enabled).  Definitions of large records can take

quite long.

New simproc record_upd_simproc for simplification of multiple record

updates enabled by default.  Moreover, trivial updates are also

removed: r(|x := x r|) = r.  INCOMPATIBILITY: old proofs break

occasionally, since simplification is more powerful by default.

* Simplifier: automatically reasons about transitivity chains

involving "trancl" (r^+) and "rtrancl" (r^*) by setting up tactics

provided by Provers/trancl.ML as additional solvers.  INCOMPATIBILITY:

old proofs break occasionally as simplification may now solve more

goals than previously.

* Simplifier: converts x <= y into x = y if assumption y <= x is

present.  Works for all partial orders (class "order"), in particular

numbers and sets.  For linear orders (e.g. numbers) it treats ~ x < y

just like y <= x.

* Simplifier: new simproc for "let x = a in f x".  If a is a free or

bound variable or a constant then the let is unfolded.  Otherwise

first a is simplified to b, and then f b is simplified to g. If

possible we abstract b from g arriving at "let x = b in h x",

otherwise we unfold the let and arrive at g.  The simproc can be

enabled/disabled by the reference use_let_simproc.  Potential

INCOMPATIBILITY since simplification is more powerful by default.

*** HOLCF ***

* HOLCF: discontinued special version of 'constdefs' (which used to

support continuous functions) in favor of the general Pure one with

full type-inference.

*** ZF ***

* ZF/ex: theories Group and Ring provide examples in abstract algebra,

including the First Isomorphism Theorem (on quotienting by the kernel

of a homomorphism).

* ZF/Simplifier: install second copy of type solver that actually

makes use of TC rules declared to Isar proof contexts (or locales);

the old version is still required for ML proof scripts.

*** ML ***

* Pure/library.ML no longer defines its own option datatype, but uses

that of the SML basis, which has constructors NONE and SOME instead of

None and Some, as well as exception Option.Option instead of OPTION.

The functions the, if_none, is_some, is_none have been adapted

accordingly, while Option.map replaces apsome.

* The exception LIST has been given up in favour of the standard

exceptions Empty and Subscript, as well as Library.UnequalLengths.

Function like Library.hd and Library.tl are superceded by the standard

hd and tl functions etc.

A number of basic functions are now no longer exported to the ML

toplevel, as they are variants of standard functions.  The following

suggests how one can translate existing code:

    rev_append xs ys = List.revAppend (xs, ys)

    nth_elem (i, xs) = List.nth (xs, i)

    last_elem xs = List.last xs

    flat xss = List.concat xss

    seq fs = List.app fs

    partition P xs = List.partition P xs

    filter P xs = List.filter P xs

    mapfilter f xs = List.mapPartial f xs

* Pure: output via the Isabelle channels of writeln/warning/error

etc. is now passed through Output.output, with a hook for arbitrary

transformations depending on the print_mode (cf. Output.add_mode --

the first active mode that provides a output function wins).  Already

formatted output may be embedded into further text via Output.raw; the

result of Pretty.string_of/str_of and derived functions

(string_of_term/cterm/thm etc.) is already marked raw to accommodate

easy composition of diagnostic messages etc.  Programmers rarely need

to care about Output.output or Output.raw at all, with some notable

exceptions: Output.output is required when bypassing the standard

channels (writeln etc.), or in token translations to produce properly

formatted results; Output.raw is required when capturing already

output material that will eventually be presented to the user a second

time.  For the default print mode, both Output.output and Output.raw

have no effect.

* Pure: print_tac now outputs the goal through the trace channel.

* Isar debugging: new reference Toplevel.debug; default false.  Set to

make printing of exceptions THM, TERM, TYPE and THEORY more verbose.

* Pure: name spaces have been refined, with significant changes of the

internal interfaces -- INCOMPATIBILITY.  Renamed cond_extern(_table)

to extern(_table).  The plain name entry path is superceded by a

general 'naming' context, which also includes the 'policy' to produce

a fully qualified name and external accesses of a fully qualified

name; NameSpace.extend is superceded by context dependent

Sign.declare_name.  Several theory and proof context operations modify

the naming context.  Especially note Theory.restore_naming and

ProofContext.restore_naming to get back to a sane state; note that

Theory.add_path is no longer sufficient to recover from

Theory.absolute_path in particular.

* Pure: new flags short_names (default false) and unique_names

(default true) for controlling output of qualified names.  If

short_names is set, names are printed unqualified.  If unique_names is

reset, the name prefix is reduced to the minimum required to achieve

the original result when interning again, even if there is an overlap

with earlier declarations.

* Pure: cases produced by proof methods specify options, where NONE

means to remove case bindings -- INCOMPATIBILITY in

(RAW_)METHOD_CASES.

* Provers: Simplifier and Classical Reasoner now support proof context

dependent plug-ins (simprocs, solvers, wrappers etc.).  These extra

components are stored in the theory and patched into the

simpset/claset when used in an Isar proof context.  Context dependent

components are maintained by the following theory operations:

  Simplifier.add_context_simprocs

  Simplifier.del_context_simprocs

  Simplifier.set_context_subgoaler

  Simplifier.reset_context_subgoaler

  Simplifier.add_context_looper

  Simplifier.del_context_looper

  Simplifier.add_context_unsafe_solver

  Simplifier.add_context_safe_solver

  Classical.add_context_safe_wrapper

  Classical.del_context_safe_wrapper

  Classical.add_context_unsafe_wrapper

  Classical.del_context_unsafe_wrapper

IMPORTANT NOTE: proof tools (methods etc.) need to use

local_simpset_of and local_claset_of to instead of the primitive

Simplifier.get_local_simpset and Classical.get_local_claset,

respectively, in order to see the context dependent fields!

*** System ***

* Allow symlinks to all proper Isabelle executables (Isabelle,

isabelle, isatool etc.).

* ISABELLE_DOC_FORMAT setting specifies preferred document format (for

isatool doc, isatool mkdir, display_drafts etc.).

* isatool usedir: option -f allows specification of the ML file to be

used by Isabelle; default is ROOT.ML.

* HOL: isatool dimacs2hol converts files in DIMACS CNF format

(containing Boolean satisfiability problems) into Isabelle/HOL

theories.

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 ***

* Proof import: new image HOL4 contains the imported library from

  the HOL4 system with about 2500 theorems. It is imported by

  replaying proof terms produced by HOL4 in Isabelle. The HOL4 image

  can be used like any other Isabelle image.  See

  HOL/Import/HOL/README for more information.

* 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 latex output syntax of UN and INT has been changed

  from "\Union x \in A. B" to "\Union_{x \in A} B"

  i.e. the index formulae has become a subscript.

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

* 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.

* HOL/List: Ordering "lexico" is renamed "lenlex" and the standard

  lexicographic dictonary ordering has been added as "lexord".

* 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 (Gdel'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 Kammller, 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";