Isabelle NEWS -- history user-relevant changes

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

New in this Isabelle version

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

*** General ***

* The main reference manuals (isar-ref, implementation, system) have

been updated and extended.  Formally checked references as hyperlinks

are now available in uniform manner.

* Simplified main Isabelle executables, with less surprises on

case-insensitive file-systems (such as Mac OS).

  - The main Isabelle tool wrapper is now called "isabelle" instead of

    "isatool."

  - The former "isabelle" alias for "isabelle-process" has been

    removed (should rarely occur to regular users).

  - The former "isabelle-interface" and its alias "Isabelle" have been

    removed (interfaces are now regular Isabelle tools).

Within scripts and make files, the Isabelle environment variables

ISABELLE_TOOL and ISABELLE_PROCESS replace old ISATOOL and ISABELLE,

respectively.  (The latter are still available as legacy feature.)

The old isabelle-interface wrapper could react in confusing ways if

the interface was uninstalled or changed otherwise.  Individual

interface tool configuration is now more explicit, see also the

Isabelle system manual.  In particular, Proof General is now available

via "isabelle emacs".

INCOMPATIBILITY, need to adapt derivative scripts.  Users may need to

purge installed copies of Isabelle executables and re-run "isabelle

install -p ...", or use symlinks.

* The default for ISABELLE_HOME_USER is now ~/.isabelle instead of the

old ~/isabelle, which was slightly non-standard and apt cause

surprises on case-insensitive file-systems.

INCOMPATIBILITY, need to move existing ~/isabelle/etc,

~/isabelle/heaps, ~/isabelle/browser_info to the new place.  Special

care is required when using older releases of Isabelle.  Note that

ISABELLE_HOME_USER can be changed in Isabelle/etc/settings of any

Isabelle distribution.

* Proofs of fully specified statements are run in parallel on

multi-core systems.  A speedup factor of 2-3 can be expected on a

regular 4-core machine, if the initial heap space is made reasonably

large (cf. Poly/ML option -H).  [Poly/ML 5.2.1 or later]

* Generalized Isar history, with support for linear undo, direct state

addressing etc.

* Recovered hiding of consts, which was accidentally broken in

Isabelle2007.  Potential INCOMPATIBILITY, ``hide const c'' really

makes c inaccessible; consider using ``hide (open) const c'' instead.

* Removed exotic 'token_translation' command.  INCOMPATIBILITY, use ML

interface instead.

* There is a new syntactic category "float_const" for signed decimal

fractions (e.g. 123.45 or -123.45).

* New prover for coherent logic (see src/Tools/coherent.ML).

*** Pure ***

* Class declaration: sc. "base sort" must not be given in import list

any longer but is inferred from the specification.  Particularly in HOL,

write

    class foo = ...     instead of      class foo = type + ...

* Module moves in repository:

    src/Pure/Tools/value.ML ~> src/Tools/

    src/Pure/Tools/quickcheck.ML ~> src/Tools/

* Slightly more coherent Pure syntax, with updated documentation in

isar-ref manual.  Removed locales meta_term_syntax and

meta_conjunction_syntax: TERM and &&& (formerly &&) are now permanent,

INCOMPATIBILITY in rare situations.

* Goal-directed proof now enforces strict proof irrelevance wrt. sort

hypotheses.  Sorts required in the course of reasoning need to be

covered by the constraints in the initial statement, completed by the

type instance information of the background theory.  Non-trivial sort

hypotheses, which rarely occur in practice, may be specified via

vacuous propositions of the form SORT_CONSTRAINT('a::c).  For example:

  lemma assumes "SORT_CONSTRAINT('a::empty)" shows False ...

The result contains an implicit sort hypotheses as before --

SORT_CONSTRAINT premises are eliminated as part of the canonical rule

normalization.

* Changed defaults for unify configuration options:

  unify_trace_bound = 50 (formerly 25)

  unify_search_bound = 60 (formerly 30)

* Different bookkeeping for code equations (INCOMPATIBILITY):

  a) On theory merge, the last set of code equations for a particular

     constant is taken (in accordance with the policy applied by other

     parts of the code generator framework).

  b) Code equations stemming from explicit declarations (e.g. code

     attribute) gain priority over default code equations stemming

     from definition, primrec, fun etc.

* Global versions of theorems stemming from classes do not carry a

parameter prefix any longer.  INCOMPATIBILITY.

* Dropped locale element "includes".  This is a major INCOMPATIBILITY.

In existing theorem specifications replace the includes element by the

respective context elements of the included locale, omitting those

that are already present in the theorem specification.  Multiple

assume elements of a locale should be replaced by a single one

involving the locale predicate.  In the proof body, declarations (most

notably theorems) may be regained by interpreting the respective

locales in the proof context as required (command "interpret").

If using "includes" in replacement of a target solely because the

parameter types in the theorem are not as general as in the target,

consider declaring a new locale with additional type constraints on

the parameters (context element "constrains").

* Dropped "locale (open)".  INCOMPATIBILITY.

* Interpretation commands no longer attempt to simplify goal.

INCOMPATIBILITY: in rare situations the generated goal differs.  Use

methods intro_locales and unfold_locales to clarify.

* Interpretation commands no longer accept interpretation attributes.

INCOMPATBILITY.

* Complete re-implementation of locales.  INCOMPATIBILITY.  The most

important changes are listed below.  See documentation (forthcoming)

and tutorial (also forthcoming) for details.

- In locale expressions, instantiation replaces renaming.  Parameters

must be declared in a for clause.  To aid compatibility with previous

parameter inheritance, in locale declarations, parameters that are not

'touched' (instantiation position "_" or omitted) are implicitly added

with their syntax at the beginning of the for clause.

- Syntax from abbreviations and definitions in locales is available in

locale expressions and context elements.  The latter is particularly

useful in locale declarations.

- More flexible mechanisms to qualify names generated by locale

expressions.  Qualifiers (prefixes) may be specified in locale

expressions.  Available are normal qualifiers (syntax "name:") and

strict qualifiers (syntax "name!:").  The latter must occur in name

references and are useful to avoid accidental hiding of names, the

former are optional.  Qualifiers derived from the parameter names of a

locale are no longer generated.

- "sublocale l < e" replaces "interpretation l < e".  The

instantiation clause in "interpretation" and "interpret" (square

brackets) is no longer available.  Use locale expressions.

- When converting proof scripts, be sure to replace qualifiers in

"interpretation" and "interpret" by strict qualifiers.  Qualifiers in

locale expressions range over a single locale instance only.

* Command 'instance': attached definitions no longer accepted.

INCOMPATIBILITY, use proper 'instantiation' target.

* Keyword 'code_exception' now named 'code_abort'.  INCOMPATIBILITY.

* The 'axiomatization' command now only works within a global theory

context.  INCOMPATIBILITY.

* New find_theorems criterion "solves" matching theorems that directly

solve the current goal. Try "find_theorems solves".

* Added an auto solve option, which can be enabled through the

ProofGeneral Isabelle settings menu (disabled by default).

When enabled, find_theorems solves is called whenever a new lemma is

stated. Any theorems that could solve the lemma directly are listed

underneath the goal.

* New command 'find_consts' searches for constants based on type and

name patterns, e.g.

    find_consts "_ => bool"

By default, matching is against subtypes, but it may be restricted to

the whole type. Searching by name is possible. Multiple queries are

conjunctive and queries may be negated by prefixing them with a

hyphen:

    find_consts strict: "_ => bool" name: "Int" -"int => int"

* New command 'local_setup' is similar to 'setup', but operates on a

local theory context.

*** Document preparation ***

* Antiquotation @{lemma} now imitates a regular terminal proof,

demanding keyword 'by' and supporting the full method expression

syntax just like the Isar command 'by'.

*** HOL ***

* Theory Library/Diagonalize.thy provides constructive version of

Cantor's first diagonalization argument.

* New predicate "strict_mono" classifies strict functions on partial orders.

With strict functions on linear orders, reasoning about (in)equalities is

facilitated by theorems "strict_mono_eq", "strict_mono_less_eq" and "strict_mono_less".

* Some set operations are now proper qualified constants with authentic syntax.

INCOMPATIBILITY:

    op Int ~>   Set.Int

    op Un ~>    Set.Un

    INTER ~>    Set.INTER

    UNION ~>    Set.UNION

    Inter ~>    Set.Inter

    Union ~>    Set.Union

    {} ~>       Set.empty

    UNIV ~>     Set.UNIV

* Class complete_lattice with operations Inf, Sup, INFI, SUPR now in theory

Set.

* Auxiliary class "itself" has disappeared -- classes without any parameter

are treated as expected by the 'class' command.

* Leibnitz's Series for Pi and the arcus tangens and logarithm series.

* Common decision procedures (Cooper, MIR, Ferrack, Approximation, Dense_Linear_Order)

now in directory HOL/Decision_Procs.

* Theory HOL/Decisioin_Procs/Approximation.thy provides the new proof method

"approximation".  It proves formulas on real values by using interval arithmetic.

In the formulas are also the transcendental functions sin, cos, tan, atan, ln,

exp and the constant pi are allowed. For examples see

HOL/Descision_Procs/ex/Approximation_Ex.thy.

* Theory "Reflection" now resides in HOL/Library.

* Entry point to Word library now simply named "Word".  INCOMPATIBILITY.

* Made source layout more coherent with logical distribution

structure:

    src/HOL/Library/RType.thy ~> src/HOL/Typerep.thy

    src/HOL/Library/Code_Message.thy ~> src/HOL/

    src/HOL/Library/GCD.thy ~> src/HOL/

    src/HOL/Library/Order_Relation.thy ~> src/HOL/

    src/HOL/Library/Parity.thy ~> src/HOL/

    src/HOL/Library/Univ_Poly.thy ~> src/HOL/

    src/HOL/Real/ContNotDenum.thy ~> src/HOL/Library/

    src/HOL/Real/Lubs.thy ~> src/HOL/

    src/HOL/Real/PReal.thy ~> src/HOL/

    src/HOL/Real/Rational.thy ~> src/HOL/

    src/HOL/Real/RComplete.thy ~> src/HOL/

    src/HOL/Real/RealDef.thy ~> src/HOL/

    src/HOL/Real/RealPow.thy ~> src/HOL/

    src/HOL/Real/Real.thy ~> src/HOL/

    src/HOL/Complex/Complex_Main.thy ~> src/HOL/

    src/HOL/Complex/Complex.thy ~> src/HOL/

    src/HOL/Complex/FrechetDeriv.thy ~> src/HOL/Library/

    src/HOL/Complex/Fundamental_Theorem_Algebra.thy ~> src/HOL/Library/

    src/HOL/Hyperreal/Deriv.thy ~> src/HOL/

    src/HOL/Hyperreal/Fact.thy ~> src/HOL/

    src/HOL/Hyperreal/Integration.thy ~> src/HOL/

    src/HOL/Hyperreal/Lim.thy ~> src/HOL/

    src/HOL/Hyperreal/Ln.thy ~> src/HOL/

    src/HOL/Hyperreal/Log.thy ~> src/HOL/

    src/HOL/Hyperreal/MacLaurin.thy ~> src/HOL/

    src/HOL/Hyperreal/NthRoot.thy ~> src/HOL/

    src/HOL/Hyperreal/Series.thy ~> src/HOL/

    src/HOL/Hyperreal/SEQ.thy ~> src/HOL/

    src/HOL/Hyperreal/Taylor.thy ~> src/HOL/

    src/HOL/Hyperreal/Transcendental.thy ~> src/HOL/

    src/HOL/Real/Float ~> src/HOL/Library/

    src/HOL/Real/HahnBanach ~> src/HOL/HahnBanach

    src/HOL/Real/RealVector.thy ~> src/HOL/

    src/HOL/arith_data.ML ~> src/HOL/Tools

    src/HOL/hologic.ML ~> src/HOL/Tools

    src/HOL/simpdata.ML ~> src/HOL/Tools

    src/HOL/int_arith1.ML ~> src/HOL/Tools/int_arith.ML

    src/HOL/int_factor_simprocs.ML ~> src/HOL/Tools

    src/HOL/nat_simprocs.ML ~> src/HOL/Tools

    src/HOL/Real/float_arith.ML ~> src/HOL/Tools

    src/HOL/Real/float_syntax.ML ~> src/HOL/Tools

    src/HOL/Real/rat_arith.ML ~> src/HOL/Tools

    src/HOL/Real/real_arith.ML ~> src/HOL/Tools

    src/HOL/Library/Array.thy ~> src/HOL/Imperative_HOL

    src/HOL/Library/Heap_Monad.thy ~> src/HOL/Imperative_HOL

    src/HOL/Library/Heap.thy ~> src/HOL/Imperative_HOL

    src/HOL/Library/Imperative_HOL.thy ~> src/HOL/Imperative_HOL

    src/HOL/Library/Ref.thy ~> src/HOL/Imperative_HOL

    src/HOL/Library/Relational.thy ~> src/HOL/Imperative_HOL

* If methods "eval" and "evaluation" encounter a structured proof state

with !!/==>, only the conclusion is evaluated to True (if possible),

avoiding strange error messages.

* Simplifier: simproc for let expressions now unfolds if bound variable

occurs at most once in let expression body.  INCOMPATIBILITY.

* New classes "top" and "bot" with corresponding operations "top" and "bot"

in theory Orderings;  instantiation of class "complete_lattice" requires

instantiation of classes "top" and "bot".  INCOMPATIBILITY.

* Changed definition lemma "less_fun_def" in order to provide an instance

for preorders on functions;  use lemma "less_le" instead.  INCOMPATIBILITY.

* Unified theorem tables for both code code generators.  Thus

[code func] has disappeared and only [code] remains.  INCOMPATIBILITY.

* Constants "undefined" and "default" replace "arbitrary".  Usually

"undefined" is the right choice to replace "arbitrary", though logically

there is no difference.  INCOMPATIBILITY.

* Generic ATP manager for Sledgehammer, based on ML threads instead of

Posix processes.  Avoids potentially expensive forking of the ML

process.  New thread-based implementation also works on non-Unix

platforms (Cygwin).  Provers are no longer hardwired, but defined

within the theory via plain ML wrapper functions.  Basic Sledgehammer

commands are covered in the isar-ref manual.

* Wrapper scripts for remote SystemOnTPTP service allows to use

sledgehammer without local ATP installation (Vampire etc.). Other

provers may be included via suitable ML wrappers, see also

src/HOL/ATP_Linkup.thy.

* Normalization by evaluation now allows non-leftlinear equations.

Declare with attribute [code nbe].

* Command "value" now integrates different evaluation

mechanisms.  The result of the first successful evaluation mechanism

is printed.  In square brackets a particular named evaluation

mechanisms may be specified (currently, [SML], [code] or [nbe]).  See

further src/HOL/ex/Eval_Examples.thy.

* New method "sizechange" to automate termination proofs using (a

modification of) the size-change principle. Requires SAT solver. See

src/HOL/ex/Termination.thy for examples.

* HOL/Orderings: class "wellorder" moved here, with explicit induction

rule "less_induct" as assumption.  For instantiation of "wellorder" by

means of predicate "wf", use rule wf_wellorderI.  INCOMPATIBILITY.

* HOL/Orderings: added class "preorder" as superclass of "order".

INCOMPATIBILITY: Instantiation proofs for order, linorder

etc. slightly changed.  Some theorems named order_class.* now named

preorder_class.*.

* HOL/Relation:

Renamed "refl" to "refl_on", "reflexive" to "refl, "diag" to "Id_on".

* HOL/Finite_Set: added a new fold combinator of type

  ('a => 'b => 'b) => 'b => 'a set => 'b

Occasionally this is more convenient than the old fold combinator which is

now defined in terms of the new one and renamed to fold_image.

* HOL/Ring_and_Field and HOL/OrderedGroup: The lemmas "group_simps" and

"ring_simps" have been replaced by "algebra_simps" (which can be extended with

further lemmas!). At the moment both still exist but the former will disappear

at some point.

* HOL/Power: Lemma power_Suc is now declared as a simp rule in class

recpower.  Type-specific simp rules for various recpower types have

been removed.  INCOMPATIBILITY.  Rename old lemmas as follows:

rat_power_0    -> power_0

rat_power_Suc  -> power_Suc

realpow_0      -> power_0

realpow_Suc    -> power_Suc

complexpow_0   -> power_0

complexpow_Suc -> power_Suc

power_poly_0   -> power_0

power_poly_Suc -> power_Suc

* HOL/Ring_and_Field and HOL/Divides: Definition of "op dvd" has been

moved to separate class dvd in Ring_and_Field; a couple of lemmas on

dvd has been generalized to class comm_semiring_1.  Likewise a bunch

of lemmas from Divides has been generalized from nat to class

semiring_div.  INCOMPATIBILITY.  This involves the following theorem

renames resulting from duplicate elimination:

    dvd_def_mod ~>          dvd_eq_mod_eq_0

    zero_dvd_iff ~>         dvd_0_left_iff

    dvd_0 ~>                dvd_0_right

    DIVISION_BY_ZERO_DIV ~> div_by_0

    DIVISION_BY_ZERO_MOD ~> mod_by_0

    mult_div ~>             div_mult_self2_is_id

    mult_mod ~>             mod_mult_self2_is_0

* HOL/IntDiv: removed many lemmas that are instances of class-based

generalizations (from Divides and Ring_and_Field).

INCOMPATIBILITY. Rename old lemmas as follows:

dvd_diff               -> nat_dvd_diff

dvd_zminus_iff         -> dvd_minus_iff

mod_add1_eq            -> mod_add_eq

mod_mult1_eq           -> mod_mult_right_eq

mod_mult1_eq'          -> mod_mult_left_eq

mod_mult_distrib_mod   -> mod_mult_eq

nat_mod_add_left_eq    -> mod_add_left_eq

nat_mod_add_right_eq   -> mod_add_right_eq

nat_mod_div_trivial    -> mod_div_trivial

nat_mod_mod_trivial    -> mod_mod_trivial

zdiv_zadd_self1        -> div_add_self1

zdiv_zadd_self2        -> div_add_self2

zdiv_zmult_self1       -> div_mult_self2_is_id

zdiv_zmult_self2       -> div_mult_self1_is_id

zdvd_triv_left         -> dvd_triv_left

zdvd_triv_right        -> dvd_triv_right

zdvd_zmult_cancel_disj -> dvd_mult_cancel_left

zmod_eq0_zdvd_iff      -> dvd_eq_mod_eq_0[symmetric]

zmod_zadd_left_eq      -> mod_add_left_eq

zmod_zadd_right_eq     -> mod_add_right_eq

zmod_zadd_self1        -> mod_add_self1

zmod_zadd_self2        -> mod_add_self2

zmod_zadd1_eq          -> mod_add_eq

zmod_zdiff1_eq         -> mod_diff_eq

zmod_zdvd_zmod         -> mod_mod_cancel

zmod_zmod_cancel       -> mod_mod_cancel

zmod_zmult_self1       -> mod_mult_self2_is_0

zmod_zmult_self2       -> mod_mult_self1_is_0

zmod_1                 -> mod_by_1

zdiv_1                 -> div_by_1

zdvd_abs1              -> abs_dvd_iff

zdvd_abs2              -> dvd_abs_iff

zdvd_refl              -> dvd_refl

zdvd_trans             -> dvd_trans

zdvd_zadd              -> dvd_add

zdvd_zdiff             -> dvd_diff

zdvd_zminus_iff        -> dvd_minus_iff

zdvd_zminus2_iff       -> minus_dvd_iff

zdvd_zmultD            -> dvd_mult_right

zdvd_zmultD2           -> dvd_mult_left

zdvd_zmult_mono        -> mult_dvd_mono

zdvd_0_right           -> dvd_0_right

zdvd_0_left            -> dvd_0_left_iff

zdvd_1_left            -> one_dvd

zminus_dvd_iff         -> minus_dvd_iff

* HOL/Library/GCD: Curried operations gcd, lcm (for nat) and zgcd,

zlcm (for int); carried together from various gcd/lcm developements in

the HOL Distribution.  zgcd and zlcm replace former igcd and ilcm;

corresponding theorems renamed accordingly.  INCOMPATIBILITY.  To

recover tupled syntax, use syntax declarations like:

    hide (open) const gcd

    abbreviation gcd where

      "gcd == (%(a, b). GCD.gcd a b)"

    notation (output)

      GCD.gcd ("gcd '(_, _')")

(analogously for lcm, zgcd, zlcm).

* HOL/Real/Rational: 'Fract k 0' now equals '0'.  INCOMPATIBILITY.

* The real numbers offer decimal input syntax: 12.34 is translated into

  1234/10^2. This translation is not reversed upon output.

* New ML antiquotation @{code}: takes constant as argument, generates

corresponding code in background and inserts name of the corresponding

resulting ML value/function/datatype constructor binding in place.

All occurrences of @{code} with a single ML block are generated

simultaneously.  Provides a generic and safe interface for

instrumentalizing code generation.  See HOL/ex/Code_Antiq for a toy

example, or HOL/Complex/ex/ReflectedFerrack for a more ambitious

application.  In future you ought refrain from ad-hoc compiling

generated SML code on the ML toplevel.  Note that (for technical

reasons) @{code} cannot refer to constants for which user-defined

serializations are set.  Refer to the corresponding ML counterpart

directly in that cases.

* Integrated image HOL-Complex with HOL.  Entry points Main.thy and

Complex_Main.thy remain as they are.

* New image HOL-Plain provides a minimal HOL with the most important

tools available (inductive, datatype, primrec, ...).  By convention

the corresponding theory Plain should be ancestor of every further

(library) theory.  Some library theories now have ancestor Plain

(instead of Main), thus theory Main occasionally has to be imported

explicitly.

* The metis method now fails in the usual manner, rather than raising

an exception, if it determines that it cannot prove the theorem.

* The metis method no longer fails because the theorem is too trivial

(contains the empty clause).

* Methods "case_tac" and "induct_tac" now refer to the very same rules

as the structured Isar versions "cases" and "induct", cf. the

corresponding "cases" and "induct" attributes.  Mutual induction rules

are now presented as a list of individual projections

(e.g. foo_bar.inducts for types foo and bar); the old format with

explicit HOL conjunction is no longer supported.  INCOMPATIBILITY, in

rare situations a different rule is selected --- notably nested tuple

elimination instead of former prod.exhaust: use explicit (case_tac t

rule: prod.exhaust) here.

* Attributes "cases", "induct", "coinduct" support "del" option.

* Removed fact "case_split_thm", which duplicates "case_split".

* Command 'rep_datatype': instead of theorem names the command now

takes a list of terms denoting the constructors of the type to be

represented as datatype.  The characteristic theorems have to be

proven.  INCOMPATIBILITY.  Also observe that the following theorems

have disappeared in favour of existing ones:

    unit_induct                 ~> unit.induct

    prod_induct                 ~> prod.induct

    sum_induct                  ~> sum.induct

    Suc_Suc_eq                  ~> nat.inject

    Suc_not_Zero Zero_not_Suc   ~> nat.distinct

* The option datatype has been moved to a new theory HOL/Option.thy.

Renamed option_map to Option.map, and o2s to Option.set.

* Library/Nat_Infinity: added addition, numeral syntax and more

instantiations for algebraic structures.  Removed some duplicate

theorems.  Changes in simp rules.  INCOMPATIBILITY.

* ATP selection (E/Vampire/Spass) is now via Proof General's settings

menu.

* Linear arithmetic now ignores all inequalities when

fast_arith_neq_limit is exceeded, instead of giving up entirely.

*** HOL-Algebra ***

* New locales for orders and lattices where the equivalence relation

is not restricted to equality.  INCOMPATIBILITY: all order and lattice

locales use a record structure with field eq for the equivalence.

* New theory of factorial domains.

* Units_l_inv and Units_r_inv are now simprules by default.

INCOMPATIBILITY.  Simplifier proof that require deletion of l_inv

and/or r_inv will now also require deletion of these lemmas.

* Renamed the following theorems.  INCOMPATIBILITY.

UpperD ~> Upper_memD

LowerD ~> Lower_memD

least_carrier ~> least_closed

greatest_carrier ~> greatest_closed

greatest_Lower_above ~> greatest_Lower_below

one_zero ~> carrier_one_zero

one_not_zero ~> carrier_one_not_zero  (collision with assumption)

*** HOL-NSA ***

* Created new image HOL-NSA, containing theories of nonstandard

analysis which were previously part of HOL-Complex.  Entry point

Hyperreal.thy remains valid, but theories formerly using

Complex_Main.thy should now use new entry point Hypercomplex.thy.

*** ZF ***

* Proof of Zorn's Lemma for partial orders.

*** HOLCF ***

* Reimplemented the simplification procedure for proving continuity

subgoals.  The new simproc is extensible; users can declare additional

continuity introduction rules with the attribute [cont2cont].

* The continuity simproc now uses a different introduction rule for

solving continuity subgoals on terms with lambda abstractions.  In

some rare cases the new simproc may fail to solve subgoals that the

old one could solve, and "simp add: cont2cont_LAM" may be necessary.

Potential INCOMPATIBILITY.

* The syntax of the fixrec package has changed.  The specification

syntax now conforms in style to definition, primrec, function, etc.

See HOLCF/ex/Fixrec_ex.thy for examples.  INCOMPATIBILITY.

*** ML ***

* High-level support for concurrent ML programming, see

src/Pure/Cuncurrent.  The data-oriented model of "future values" is

particularly convenient to organize independent functional

computations.  The concept of "synchronized variables" provides a

higher-order interface for components with shared state, avoiding the

delicate details of mutexes and condition variables.  [Poly/ML 5.2.1

or later]

* Simplified ML oracle interface Thm.add_oracle promotes 'a -> cterm

to 'a -> thm, while results are always tagged with an authentic oracle

name.  The Isar command 'oracle' is now polymorphic, no argument type

is specified.  INCOMPATIBILITY, need to simplify existing oracle code

accordingly.  Note that extra performance may be gained by producing

the cterm carefully, avoiding slow Thm.cterm_of.

* ML bindings produced via Isar commands are stored within the Isar

context (theory or proof).  Consequently, commands like 'use' and 'ML'

become thread-safe and work with undo as expected (concerning

top-level bindings, not side-effects on global references).

INCOMPATIBILITY, need to provide proper Isar context when invoking the

compiler at runtime; really global bindings need to be given outside a

theory. [Poly/ML 5.2 or later]

* Command 'ML_prf' is analogous to 'ML' but works within a proof

context. Top-level ML bindings are stored within the proof context in

a purely sequential fashion, disregarding the nested proof structure.

ML bindings introduced by 'ML_prf' are discarded at the end of the

proof.  [Poly/ML 5.2 or later]

* Generic Toplevel.add_hook interface allows to analyze the result of

transactions.  E.g. see src/Pure/ProofGeneral/proof_general_pgip.ML

for theorem dependency output of transactions resulting in a new

theory state.

* More systematic treatment of long names, abstract name bindings, and

name space operations.  Basic operations on qualified names have been

move from structure NameSpace to Long_Name, e.g. Long_Name.base_name,

Long_Name.append.  Old type bstring has been mostly replaced by

abstract type binding (see structure Binding), which supports precise

qualification (by packages and local theory targets), as well as

proper tracking of source positions.  INCOMPATIBILITY, need to wrap

old bstring values into Binding.name, or better pass through abstract

bindings everywhere.  See further src/Pure/General/long_name.ML,

src/Pure/General/binding.ML and src/Pure/General/name_space.ML

* Simplified interface for defining document antiquotations via

ThyOutput.antiquotation, ThyOutput.output, and optionally

ThyOutput.maybe_pretty_source.  INCOMPATIBILITY, need to simplify user

antiquotations accordingly, see src/Pure/Thy/thy_output.ML for common

examples.

* Result facts (from PureThy.note_thms, ProofContext.note_thms,

LocalTheory.note etc.) now refer to the *full* internal name, not the

bstring as before.  INCOMPATIBILITY, not detected by ML type-checking!

* Rules and tactics that read instantiations (read_instantiate,

res_inst_tac, thin_tac, subgoal_tac etc.) now demand a proper proof

context, which is required for parsing and type-checking.  Moreover,

the variables are specified as plain indexnames, not string encodings

thereof.  INCOMPATIBILITY.

* Disposed old type and term read functions (Sign.read_def_typ,

Sign.read_typ, Sign.read_def_terms, Sign.read_term,

Thm.read_def_cterms, Thm.read_cterm etc.).  INCOMPATIBILITY, should

use regular Syntax.read_typ, Syntax.read_term, Syntax.read_typ_global,

Syntax.read_term_global etc.; see also OldGoals.read_term as last

resort for legacy applications.

* Antiquotations: block-structured compilation context indicated by

\<lbrace> ... \<rbrace>; additional antiquotation forms:

  @{let ?pat = term}                      - term abbreviation (HO matching)

  @{note name = fact}                     - fact abbreviation

  @{thm fact}                             - singleton fact (with attributes)

  @{thms fact}                            - general fact (with attributes)

  @{lemma prop by method}                 - singleton goal

  @{lemma prop by meth1 meth2}            - singleton goal

  @{lemma prop1 ... propN by method}      - general goal

  @{lemma prop1 ... propN by meth1 meth2} - general goal

  @{lemma (open) ...}                     - open derivation

*** System ***

* Multithreading for Poly/ML 5.1/5.2 is no longer supported, only for

Poly/ML 5.2.1 or later.

* The Isabelle "emacs" tool provides a specific interface to invoke

Proof General / Emacs, with more explicit failure if that is not

installed (the old isabelle-interface script silently falls back on

isabelle-process).  The PROOFGENERAL_HOME setting determines the

installation location of the Proof General distribution.

* Isabelle/lib/classes/Pure.jar provides basic support to integrate

the Isabelle process into a JVM/Scala application.  See

Isabelle/lib/jedit/plugin for a minimal example.  (The obsolete Java

process wrapper has been discontinued.)

* Status messages (with exact source position information) are

emitted, if proper markup print mode is enabled.  This allows

user-interface components to provide detailed feedback on internal

prover operations.

* Homegrown Isabelle font with unicode layout, see Isabelle/lib/fonts.

New in Isabelle2008 (June 2008)

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

*** General ***

* The Isabelle/Isar Reference Manual (isar-ref) has been reorganized

and updated, with formally checked references as hyperlinks.

* Theory loader: use_thy (and similar operations) no longer set the

implicit ML context, which was occasionally hard to predict and in

conflict with concurrency.  INCOMPATIBILITY, use ML within Isar which

provides a proper context already.

* Theory loader: old-style ML proof scripts being *attached* to a thy

file are no longer supported.  INCOMPATIBILITY, regular 'uses' and

'use' within a theory file will do the job.

* Name space merge now observes canonical order, i.e. the second space

is inserted into the first one, while existing entries in the first

space take precedence.  INCOMPATIBILITY in rare situations, may try to

swap theory imports.

* Syntax: symbol \<chi> is now considered a letter.  Potential

INCOMPATIBILITY in identifier syntax etc.

* Outer syntax: string tokens no longer admit escaped white space,

which was an accidental (undocumented) feature.  INCOMPATIBILITY, use

white space without escapes.

* Outer syntax: string tokens may contain arbitrary character codes

specified via 3 decimal digits (as in SML).  E.g. "foo\095bar" for

"foo_bar".

*** Pure ***

* Context-dependent token translations.  Default setup reverts locally

fixed variables, and adds hilite markup for undeclared frees.

* Unused theorems can be found using the new command 'unused_thms'.

There are three ways of invoking it:

(1) unused_thms

     Only finds unused theorems in the current theory.

(2) unused_thms thy_1 ... thy_n -

     Finds unused theorems in the current theory and all of its ancestors,

     excluding the theories thy_1 ... thy_n and all of their ancestors.

(3) unused_thms thy_1 ... thy_n - thy'_1 ... thy'_m

     Finds unused theorems in the theories thy'_1 ... thy'_m and all of

     their ancestors, excluding the theories thy_1 ... thy_n and all of

     their ancestors.

In order to increase the readability of the list produced by

unused_thms, theorems that have been created by a particular instance

of a theory command such as 'inductive' or 'function' are considered

to belong to the same "group", meaning that if at least one theorem in

this group is used, the other theorems in the same group are no longer

reported as unused.  Moreover, if all theorems in the group are

unused, only one theorem in the group is displayed.

Note that proof objects have to be switched on in order for

unused_thms to work properly (i.e. !proofs must be >= 1, which is

usually the case when using Proof General with the default settings).

* Authentic naming of facts disallows ad-hoc overwriting of previous

theorems within the same name space.  INCOMPATIBILITY, need to remove

duplicate fact bindings, or even accidental fact duplications.  Note

that tools may maintain dynamically scoped facts systematically, using

PureThy.add_thms_dynamic.

* Command 'hide' now allows to hide from "fact" name space as well.

* Eliminated destructive theorem database, simpset, claset, and

clasimpset.  Potential INCOMPATIBILITY, really need to observe linear

update of theories within ML code.

* Eliminated theory ProtoPure and CPure, leaving just one Pure theory.

INCOMPATIBILITY, object-logics depending on former Pure require

additional setup PureThy.old_appl_syntax_setup; object-logics

depending on former CPure need to refer to Pure.

* Commands 'use' and 'ML' are now purely functional, operating on

theory/local_theory.  Removed former 'ML_setup' (on theory), use 'ML'

instead.  Added 'ML_val' as mere diagnostic replacement for 'ML'.

INCOMPATIBILITY.

* Command 'setup': discontinued implicit version with ML reference.

* Instantiation target allows for simultaneous specification of class

instance operations together with an instantiation proof.

Type-checking phase allows to refer to class operations uniformly.

See src/HOL/Complex/Complex.thy for an Isar example and

src/HOL/Library/Eval.thy for an ML example.

* Indexing of literal facts: be more serious about including only

facts from the visible specification/proof context, but not the

background context (locale etc.).  Affects `prop` notation and method

"fact".  INCOMPATIBILITY: need to name facts explicitly in rare

situations.

* Method "cases", "induct", "coinduct": removed obsolete/undocumented

"(open)" option, which used to expose internal bound variables to the

proof text.

* Isar statements: removed obsolete case "rule_context".

INCOMPATIBILITY, better use explicit fixes/assumes.

* Locale proofs: default proof step now includes 'unfold_locales';

hence 'proof' without argument may be used to unfold locale

predicates.

*** Document preparation ***

* Simplified pdfsetup.sty: color/hyperref is used unconditionally for

both pdf and dvi (hyperlinks usually work in xdvi as well); removed

obsolete thumbpdf setup (contemporary PDF viewers do this on the

spot); renamed link color from "darkblue" to "linkcolor" (default

value unchanged, can be redefined via \definecolor); no longer sets

"a4paper" option (unnecessary or even intrusive).

* Antiquotation @{lemma A method} proves proposition A by the given

method (either a method name or a method name plus (optional) method

arguments in parentheses) and prints A just like @{prop A}.

*** HOL ***

* New primrec package.  Specification syntax conforms in style to

definition/function/....  No separate induction rule is provided.  The

"primrec" command distinguishes old-style and new-style specifications

by syntax.  The former primrec package is now named OldPrimrecPackage.

When adjusting theories, beware: constants stemming from new-style

primrec specifications have authentic syntax.

* Metis prover is now an order of magnitude faster, and also works

with multithreading.

* Metis: the maximum number of clauses that can be produced from a

theorem is now given by the attribute max_clauses.  Theorems that

exceed this number are ignored, with a warning printed.

* Sledgehammer no longer produces structured proofs by default. To

enable, declare [[sledgehammer_full = true]].  Attributes

reconstruction_modulus, reconstruction_sorts renamed

sledgehammer_modulus, sledgehammer_sorts.  INCOMPATIBILITY.

* Method "induct_scheme" derives user-specified induction rules

from well-founded induction and completeness of patterns. This factors

out some operations that are done internally by the function package

and makes them available separately.  See

src/HOL/ex/Induction_Scheme.thy for examples.

* More flexible generation of measure functions for termination

proofs: Measure functions can be declared by proving a rule of the

form "is_measure f" and giving it the [measure_function] attribute.

The "is_measure" predicate is logically meaningless (always true), and

just guides the heuristic.  To find suitable measure functions, the

termination prover sets up the goal "is_measure ?f" of the appropriate

type and generates all solutions by prolog-style backwards proof using

the declared rules.

This setup also deals with rules like 

  "is_measure f ==> is_measure (list_size f)"

which accommodates nested datatypes that recurse through lists.

Similar rules are predeclared for products and option types.

* Turned the type of sets "'a set" into an abbreviation for "'a => bool"

  INCOMPATIBILITIES:

  - Definitions of overloaded constants on sets have to be replaced by

    definitions on => and bool.

  - Some definitions of overloaded operators on sets can now be proved

    using the definitions of the operators on => and bool.  Therefore,

    the following theorems have been renamed:

      subset_def   -> subset_eq

      psubset_def  -> psubset_eq

      set_diff_def -> set_diff_eq

      Compl_def    -> Compl_eq

      Sup_set_def  -> Sup_set_eq

      Inf_set_def  -> Inf_set_eq

      sup_set_def  -> sup_set_eq

      inf_set_def  -> inf_set_eq

  - Due to the incompleteness of the HO unification algorithm, some

    rules such as subst may require manual instantiation, if some of

    the unknowns in the rule is a set.

  - Higher order unification and forward proofs:

    The proof pattern

      have "P (S::'a set)" <...>

      then have "EX S. P S" ..

    no longer works (due to the incompleteness of the HO unification

    algorithm) and must be replaced by the pattern

      have "EX S. P S"

      proof

        show "P S" <...>

      qed

  - Calculational reasoning with subst (or similar rules):

    The proof pattern

      have "P (S::'a set)" <...>

      also have "S = T" <...>

      finally have "P T" .

    no longer works (for similar reasons as the previous example) and

    must be replaced by something like

      have "P (S::'a set)" <...>

      moreover have "S = T" <...>

      ultimately have "P T" by simp

  - Tactics or packages written in ML code:

    Code performing pattern matching on types via

      Type ("set", [T]) => ...

    must be rewritten. Moreover, functions like strip_type or

    binder_types no longer return the right value when applied to a

    type of the form

      T1 => ... => Tn => U => bool

    rather than

      T1 => ... => Tn => U set

* Merged theories Wellfounded_Recursion, Accessible_Part and

Wellfounded_Relations to theory Wellfounded.

* Explicit class "eq" for executable equality.  INCOMPATIBILITY.

* Class finite no longer treats UNIV as class parameter.  Use class

enum from theory Library/Enum instead to achieve a similar effect.

INCOMPATIBILITY.

* Theory List: rule list_induct2 now has explicitly named cases "Nil"

and "Cons".  INCOMPATIBILITY.

* HOL (and FOL): renamed variables in rules imp_elim and swap.

Potential INCOMPATIBILITY.

* Theory Product_Type: duplicated lemmas split_Pair_apply and

injective_fst_snd removed, use split_eta and prod_eqI instead.

Renamed upd_fst to apfst and upd_snd to apsnd.  INCOMPATIBILITY.

* Theory Nat: removed redundant lemmas that merely duplicate lemmas of

the same name in theory Orderings:

  less_trans

  less_linear

  le_imp_less_or_eq

  le_less_trans

  less_le_trans

  less_not_sym

  less_asym

Renamed less_imp_le to less_imp_le_nat, and less_irrefl to

less_irrefl_nat.  Potential INCOMPATIBILITY due to more general types

and different variable names.

* Library/Option_ord.thy: Canonical order on option type.

* Library/RBT.thy: Red-black trees, an efficient implementation of

finite maps.

* Library/Countable.thy: Type class for countable types.

* Theory Int: The representation of numerals has changed.  The infix

operator BIT and the bit datatype with constructors B0 and B1 have

disappeared.  INCOMPATIBILITY, use "Int.Bit0 x" and "Int.Bit1 y" in

place of "x BIT bit.B0" and "y BIT bit.B1", respectively.  Theorems

involving BIT, B0, or B1 have been renamed with "Bit0" or "Bit1"

accordingly.

* Theory Nat: definition of <= and < on natural numbers no longer

depend on well-founded relations.  INCOMPATIBILITY.  Definitions

le_def and less_def have disappeared.  Consider lemmas not_less

[symmetric, where ?'a = nat] and less_eq [symmetric] instead.