NEWS

renamed method induct_scheme to induction_schema

Isabelle NEWS -- history user-relevant changes
==============================================

New in this Isabelle version
----------------------------

*** General ***

* Discontinued old form of "escaped symbols" such as \\<forall>.  Only
one backslash should be used, even in ML sources.


*** Pure ***

* On instantiation of classes, remaining undefined class parameters
are formally declared.  INCOMPATIBILITY.

* Locale interpretation propagates mixins along the locale hierarchy.
The currently only available mixins are the equations used to map
local definitions to terms of the target domain of an interpretation.

* Reactivated diagnositc command 'print_interps'.  Use 'print_interps l'
to print all interpretations of locale l in the theory.  Interpretations
in proofs are not shown.

* Thoroughly revised locales tutorial.  New section on conditional
interpretation.


*** document preparation ***

* New generalized style concept for printing terms:
write @{foo (style) ...} instead of @{foo_style style ...}
(old form is still retained for backward compatibility).
Styles can be also applied for antiquotations prop, term_type and typeof.


*** HOL ***

* Combined former theories Divides and IntDiv to one theory Divides
in the spirit of other number theory theories in HOL;  some constants
(and to a lesser extent also facts) have been suffixed with _nat und _int
respectively.  INCOMPATIBILITY.

* Most rules produced by inductive and datatype package
have mandatory prefixes.
INCOMPATIBILITY.

* New proof method "smt" for a combination of first-order logic
with equality, linear and nonlinear (natural/integer/real)
arithmetic, and fixed-size bitvectors; there is also basic
support for higher-order features (esp. lambda abstractions).
It is an incomplete decision procedure based on external SMT
solvers using the oracle mechanism; for the SMT solver Z3,
this method is proof-producing. Certificates are provided to
avoid calling the external solvers solely for re-checking proofs.

* New commands to load and prove verification conditions
generated by the Boogie program verifier or derived systems
(e.g. the Verifying C Compiler (VCC) or Spec#).

* New counterexample generator tool "nitpick" based on the Kodkod
relational model finder.

* Reorganization of number theory:
  * former session NumberTheory now named Old_Number_Theory
  * new session Number_Theory by Jeremy Avigad; if possible, prefer this.
  * moved legacy theories Legacy_GCD and Primes from Library/ to Old_Number_Theory/;
  * moved theory Pocklington from Library/ to Old_Number_Theory/;
  * removed various references to Old_Number_Theory from HOL distribution.
INCOMPATIBILITY.

* Theory GCD now has functions Gcd/GCD and Lcm/LCM for the gcd and lcm
of finite and infinite sets. It is shown that they form a complete
lattice.

* New theory SupInf of the supremum and infimum operators for sets of reals.

* New theory Probability, which contains a development of measure theory, eventually leading to Lebesgue integration and probability.

* Split off prime number ingredients from theory GCD
to theory Number_Theory/Primes;

* Class semiring_div requires superclass no_zero_divisors and proof of
div_mult_mult1; theorems div_mult_mult1, div_mult_mult2,
div_mult_mult1_if, div_mult_mult1 and div_mult_mult2 have been
generalized to class semiring_div, subsuming former theorems
zdiv_zmult_zmult1, zdiv_zmult_zmult1_if, zdiv_zmult_zmult1 and
zdiv_zmult_zmult2.  div_mult_mult1 is now [simp] by default.
INCOMPATIBILITY.

* New testing tool "Mirabelle" for automated (proof) tools. Applies
several tools and tactics like sledgehammer, metis, or quickcheck, to
every proof step in a theory. To be used in batch mode via the
"mirabelle" utility.

* New proof method "sos" (sum of squares) for nonlinear real
arithmetic (originally due to John Harison). It requires
Library/Sum_Of_Squares.  It is not a complete decision procedure but
works well in practice on quantifier-free real arithmetic with +, -,
*, ^, =, <= and <, i.e. boolean combinations of equalities and
inequalities between polynomials. It makes use of external
semidefinite programming solvers. Method "sos" generates a certificate
that can be pasted into the proof thus avoiding the need to call an external
tool every time the proof is checked.
For more information and examples see src/HOL/Library/Sum_Of_Squares.

* Code generator attributes follow the usual underscore convention:
    code_unfold     replaces    code unfold
    code_post       replaces    code post
    etc.
  INCOMPATIBILITY.

* Refinements to lattice classes and sets:
  - less default intro/elim rules in locale variant, more default
    intro/elim rules in class variant: more uniformity
  - lemma ge_sup_conv renamed to le_sup_iff, in accordance with le_inf_iff
  - dropped lemma alias inf_ACI for inf_aci (same for sup_ACI and sup_aci)
  - renamed ACI to inf_sup_aci
  - new class "boolean_algebra"
  - class "complete_lattice" moved to separate theory "complete_lattice";
    corresponding constants (and abbreviations) renamed and with authentic syntax:
    Set.Inf ~>      Complete_Lattice.Inf
    Set.Sup ~>      Complete_Lattice.Sup
    Set.INFI ~>     Complete_Lattice.INFI
    Set.SUPR ~>     Complete_Lattice.SUPR
    Set.Inter ~>    Complete_Lattice.Inter
    Set.Union ~>    Complete_Lattice.Union
    Set.INTER ~>    Complete_Lattice.INTER
    Set.UNION ~>    Complete_Lattice.UNION
  - more convenient names for set intersection and union:
    Set.Int ~>      Set.inter
    Set.Un ~>       Set.union
  - authentic syntax for
    Set.Pow
    Set.image
  - mere abbreviations:
    Set.empty               (for bot)
    Set.UNIV                (for top)
    Set.inter               (for inf)
    Set.union               (for sup)
    Complete_Lattice.Inter  (for Inf)
    Complete_Lattice.Union  (for Sup)
    Complete_Lattice.INTER  (for INFI)
    Complete_Lattice.UNION  (for SUPR)
  - object-logic definitions as far as appropriate

INCOMPATIBILITY.  Care is required when theorems Int_subset_iff or
Un_subset_iff are explicitly deleted as default simp rules;  then
also their lattice counterparts le_inf_iff and le_sup_iff have to be
deleted to achieve the desired effect.

* Rules inf_absorb1, inf_absorb2, sup_absorb1, sup_absorb2 are no
simp rules by default any longer.  The same applies to
min_max.inf_absorb1 etc.!  INCOMPATIBILITY.

* sup_Int_eq and sup_Un_eq are no default pred_set_conv rules any longer.
INCOMPATIBILITY.

* Power operations on relations and functions are now one dedicate
constant "compow" with infix syntax "^^".  Power operation on
multiplicative monoids retains syntax "^" and is now defined generic
in class power.  INCOMPATIBILITY.

* Relation composition "R O S" now has a "more standard" argument
order, i.e., "R O S = {(x,z). EX y. (x,y) : R & (y,z) : S }".
INCOMPATIBILITY: Rewrite propositions with "S O R" --> "R O S". Proofs
may occationally break, since the O_assoc rule was not rewritten like
this.  Fix using O_assoc[symmetric].  The same applies to the curried
version "R OO S".

* Function "Inv" is renamed to "inv_into" and function "inv" is now an
abbreviation for "inv_into UNIV". Lemmas are renamed accordingly.
INCOMPATIBILITY.

* ML antiquotation @{code_datatype} inserts definition of a datatype
generated by the code generator; see Predicate.thy for an example.

* New method "linarith" invokes existing linear arithmetic decision
procedure only.

* New implementation of quickcheck uses generic code generator;
default generators are provided for all suitable HOL types, records
and datatypes.  Old quickcheck can be re-activated importing
theory Library/SML_Quickcheck.

* Renamed theorems:
Suc_eq_add_numeral_1 -> Suc_eq_plus1
Suc_eq_add_numeral_1_left -> Suc_eq_plus1_left
Suc_plus1 -> Suc_eq_plus1

* Moved theorems:
Wellfounded.in_inv_image -> Relation.in_inv_image

* New sledgehammer option "Full Types" in Proof General settings menu.
Causes full type information to be output to the ATPs.  This slows
ATPs down considerably but eliminates a source of unsound "proofs"
that fail later.

* New method metisFT: A version of metis that uses full type information
in order to avoid failures of proof reconstruction.

* Discontinued ancient tradition to suffix certain ML module names
with "_package", e.g.:

    DatatypePackage ~> Datatype
    InductivePackage ~> Inductive

INCOMPATIBILITY.

* Discontinued abbreviation "arbitrary" of constant
"undefined". INCOMPATIBILITY, use "undefined" directly.

* New evaluator "approximate" approximates an real valued term using
the same method as the approximation method.

* Method "approximate" supports now arithmetic expressions as
boundaries of intervals and implements interval splitting and Taylor
series expansion.

* Changed DERIV_intros to a dynamic fact (via Named_Thms).  Each of
the theorems in DERIV_intros assumes composition with an additional
function and matches a variable to the derivative, which has to be
solved by the simplifier.  Hence (auto intro!: DERIV_intros) computes
the derivative of most elementary terms.

* Maclauren.DERIV_tac and Maclauren.deriv_tac was removed, they are
replaced by: (auto intro!: DERIV_intros).  INCOMPATIBILITY.

* Renamed methods:
    sizechange -> size_change
    induct_scheme -> induction_schema


*** ML ***

* Removed some old-style infix operations using polymorphic equality.
INCOMPATIBILITY.

* Structure Synchronized (cf. src/Pure/Concurrent/synchronized.ML)
provides a high-level programming interface to synchronized state
variables with atomic update.  This works via pure function
application within a critical section -- its runtime should be as
short as possible; beware of deadlocks if critical code is nested,
either directly or indirectly via other synchronized variables!

* Structure Unsynchronized (cf. src/Pure/ML-Systems/unsynchronized.ML)
wraps raw ML references, explicitly indicating their non-thread-safe
behaviour.  The Isar toplevel keeps this structure open, to
accommodate Proof General as well as quick and dirty interactive
experiments with references.

* PARALLEL_CHOICE and PARALLEL_GOALS provide basic support for
parallel tactical reasoning.

* Tacticals Subgoal.FOCUS, Subgoal.FOCUS_PREMS, Subgoal.FOCUS_PARAMS
are similar to SUBPROOF, but are slightly more flexible: only the
specified parts of the subgoal are imported into the context, and the
body tactic may introduce new subgoals and schematic variables.

* Old tactical METAHYPS, which does not observe the proof context, has
been renamed to Old_Goals.METAHYPS and awaits deletion.  Use SUBPROOF
or Subgoal.FOCUS etc.

* Renamed functor TableFun to Table, and GraphFun to Graph.  (Since
functors have their own ML name space there is no point to mark them
separately.)  Minor INCOMPATIBILITY.

* Renamed NamedThmsFun to Named_Thms.  INCOMPATIBILITY.

* Eliminated old Attrib.add_attributes, Method.add_methods and related
cominators for "args".  INCOMPATIBILITY, need to use simplified
Attrib/Method.setup introduced in Isabelle2009.

* Proper context for simpset_of, claset_of, clasimpset_of.  May fall
back on global_simpset_of, global_claset_of, global_clasimpset_of as
last resort.  INCOMPATIBILITY.

* Display.pretty_thm now requires a proper context (cf. former
ProofContext.pretty_thm).  May fall back on Display.pretty_thm_global
or even Display.pretty_thm_without_context as last resort.
INCOMPATIBILITY.

* Discontinued Display.pretty_ctyp/cterm etc.  INCOMPATIBILITY, use
Syntax.pretty_typ/term directly, preferably with proper context
instead of global theory.

* Operations of structure Skip_Proof (formerly SkipProof) no longer
require quick_and_dirty mode, which avoids critical setmp.


*** System ***

* Support for additional "Isabelle components" via etc/components, see
also the system manual.

* The isabelle makeall tool now operates on all components with
IsaMakefile, not just hardwired "logics".

* Discontinued support for Poly/ML 4.x versions.

* Removed "compress" option from isabelle-process and isabelle usedir;
this is always enabled.

* More fine-grained control of proof parallelism, cf.
Goal.parallel_proofs in ML and usedir option -q LEVEL.



New in Isabelle2009 (April 2009)
--------------------------------

*** General ***

* 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 to cause
surprises on case-insensitive file-systems (such as Mac OS).

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, in order to use the new ~/.isabelle uniformly.

* Proofs of fully specified statements are run in parallel on
multi-core systems.  A speedup factor of 2.5 to 3.2 can be expected on
a regular 4-core machine, if the initial heap space is made reasonably
large (cf. Poly/ML option -H).  (Requires Poly/ML 5.2.1 or later.)

* The main reference manuals ("isar-ref", "implementation", and
"system") have been updated and extended.  Formally checked references
as hyperlinks are now available uniformly.


*** Pure ***

* Complete re-implementation of locales.  INCOMPATIBILITY in several
respects.  The most important changes are listed below.  See the
Tutorial on Locales ("locales" manual) 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, and can be marked as mandatory (syntax: "name!:") or
optional (syntax "name?:").  The default depends for plain "name:"
depends on the situation where a locale expression is used: in
commands 'locale' and 'sublocale' prefixes are optional, in
'interpretation' and 'interpret' prefixes are mandatory.  The old
implicit qualifiers derived from the parameter names of a locale are
no longer generated.

- Command "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, mandatory qualifiers in
'interpretation' and 'interpret' should be retained by default, even
if this is an INCOMPATIBILITY compared to former behavior.  In the
worst case, use the "name?:" form for non-mandatory ones.  Qualifiers
in locale expressions range over a single locale instance only.

- 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").

- Discontinued "locale (open)".  INCOMPATIBILITY.

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

- Locale interpretation commands no longer accept interpretation
attributes.  INCOMPATIBILITY.

* Class declaration: so-called "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 + ...

* Class target: global versions of theorems stemming do not carry a
parameter prefix any longer.  INCOMPATIBILITY.

* Class 'instance' command no longer accepts attached definitions.
INCOMPATIBILITY, use proper 'instantiation' target instead.

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

* 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.  Note that &&& should not be used
directly in regular applications.

* There is a new syntactic category "float_const" for signed decimal
fractions (e.g. 123.45 or -123.45).

* Removed exotic 'token_translation' command.  INCOMPATIBILITY, use ML
interface with 'setup' command instead.

* Command 'local_setup' is similar to 'setup', but operates on a local
theory context.

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

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

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

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

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

* Unified theorem tables for both code generators.  Thus [code
func] has disappeared and only [code] remains.  INCOMPATIBILITY.

* 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 'find_theorems' criterion "solves" matches theorems that
directly solve the current goal (modulo higher-order unification).

* Auto solve feature for main theorem statements: whenever a new goal
is stated, "find_theorems solves" is called; any theorems that could
solve the lemma directly are listed as part of the goal state.
Cf. associated options in Proof General Isabelle settings menu,
enabled by default, with reasonable timeout for pathological cases of
higher-order unification.


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

* Integrated main parts of former image HOL-Complex with HOL.  Entry
points Main and Complex_Main remain as before.

* Logic image HOL-Plain provides a minimal HOL with the most important
tools available (inductive, datatype, primrec, ...).  This facilitates
experimentation and tool development.  Note that user applications
(and library theories) should never refer to anything below theory
Main, as before.

* Logic image HOL-Main stops at theory Main, and thus facilitates
experimentation due to shorter build times.

* Logic image HOL-NSA contains theories of nonstandard analysis which
were previously part of former HOL-Complex.  Entry point Hyperreal
remains valid, but theories formerly using Complex_Main should now use
new entry point Hypercomplex.

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

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

* The metis method no longer fails because the theorem is too trivial
(contains the empty clause).

* The metis method now fails in the usual manner, rather than raising
an exception, if it determines that it cannot prove the theorem.

* Method "coherent" implements a prover for coherent logic (see also
src/Tools/coherent.ML).

* Constants "undefined" and "default" replace "arbitrary".  Usually
"undefined" is the right choice to replace "arbitrary", though
logically there is no difference.  INCOMPATIBILITY.

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

* Normalization by evaluation now allows non-leftlinear equations.
Declare with attribute [code nbe].

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

* The option datatype has been moved to a new theory Option.  Renamed
option_map to Option.map, and o2s to Option.set, INCOMPATIBILITY.

* 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) are now in directory HOL/Decision_Procs.

* Theory src/HOL/Decision_Procs/Approximation 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
src/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.

* Method "sizechange" automates termination proofs using (a
modification of) the size-change principle.  Requires SAT solver.  See
src/HOL/ex/Termination.thy for examples.

* Simplifier: simproc for let expressions now unfolds if bound
variable occurs at most once in let expression body.  INCOMPATIBILITY.

* Method "arith": Linear arithmetic now ignores all inequalities when
fast_arith_neq_limit is exceeded, instead of giving up entirely.

* New attribute "arith" for facts that should always be used
automatically by arithmetic. It is intended to be used locally in
proofs, e.g.

  assumes [arith]: "x > 0"

Global usage is discouraged because of possible performance impact.

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

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

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

* Theory Relation: renamed "refl" to "refl_on", "reflexive" to "refl,
"diag" to "Id_on".

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

* Theories Ring_and_Field and 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.

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

* Theories Ring_and_Field and 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

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

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

* Theory Library/Polynomial defines an abstract type 'a poly of
univariate polynomials with coefficients of type 'a.  In addition to
the standard ring operations, it also supports div and mod.  Code
generation is also supported, using list-style constructors.

* Theory Library/Inner_Product defines a class of real_inner for real
inner product spaces, with an overloaded operation inner :: 'a => 'a
=> real.  Class real_inner is a subclass of real_normed_vector from
theory RealVector.

* Theory Library/Product_Vector provides instances for the product
type 'a * 'b of several classes from RealVector and Inner_Product.
Definitions of addition, subtraction, scalar multiplication, norms,
and inner products are included.

* Theory Library/Bit defines the field "bit" of integers modulo 2.  In
addition to the field operations, numerals and case syntax are also
supported.

* Theory Library/Diagonalize provides constructive version of Cantor's
first diagonalization argument.

* Theory Library/GCD: Curried operations gcd, lcm (for nat) and zgcd,
zlcm (for int); carried together from various gcd/lcm developements in
the HOL Distribution.  Constants zgcd and zlcm replace former igcd and
ilcm; corresponding theorems renamed accordingly.  INCOMPATIBILITY,
may recover tupled syntax as follows:

    hide (open) const gcd
    abbreviation gcd where
      "gcd == (%(a, b). GCD.gcd a b)"
    notation (output)
      GCD.gcd ("gcd '(_, _')")

The same works for lcm, zgcd, zlcm.

* Theory Library/Nat_Infinity: added addition, numeral syntax and more
instantiations for algebraic structures.  Removed some duplicate
theorems.  Changes in simp rules.  INCOMPATIBILITY.

* ML antiquotation @{code} takes a constant as argument and 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
src/HOL/Decision_Procs/Ferrack.thy for a more ambitious application.
In future you ought to 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.

* 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


*** 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 simp rules 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-Nominal ***

* Nominal datatypes can now contain type-variables.

* Commands 'nominal_inductive' and 'equivariance' work with local
theory targets.

* Nominal primrec can now works with local theory targets and its
specification syntax now conforms to the general format as seen in
'inductive' etc.

* Method "perm_simp" honours the standard simplifier attributes
(no_asm), (no_asm_use) etc.

* The new predicate #* is defined like freshness, except that on the
left hand side can be a set or list of atoms.

* Experimental command 'nominal_inductive2' derives strong induction
principles for inductive definitions.  In contrast to
'nominal_inductive', which can only deal with a fixed number of
binders, it can deal with arbitrary expressions standing for sets of
atoms to be avoided.  The only inductive definition we have at the
moment that needs this generalisation is the typing rule for Lets in
the algorithm W:

 Gamma |- t1 : T1   (x,close Gamma T1)::Gamma |- t2 : T2   x#Gamma
 -----------------------------------------------------------------
         Gamma |- Let x be t1 in t2 : T2

In this rule one wants to avoid all the binders that are introduced by
"close Gamma T1".  We are looking for other examples where this
feature might be useful.  Please let us know.


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

* Command 'fixrec': specification syntax now conforms to the general
format as seen in 'inductive' etc.  See src/HOLCF/ex/Fixrec_ex.thy for
examples.  INCOMPATIBILITY.


*** ZF ***

* Proof of Zorn's Lemma for partial orders.


*** ML ***

* Multithreading for Poly/ML 5.1/5.2 is no longer supported, only for
Poly/ML 5.2.1 or later.  Important note: the TimeLimit facility
depends on multithreading, so timouts will not work before Poly/ML
5.2.1!

* 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.  (Requires
Poly/ML 5.2.1 or later.)

* 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.  (Requires 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.  (Requires Poly/ML 5.2 or later.)

* Simplified ML attribute and method setup, cf. functions Attrib.setup
and Method.setup, as well as Isar commands 'attribute_setup' and
'method_setup'.  INCOMPATIBILITY for 'method_setup', need to simplify
existing code accordingly, or use plain 'setup' together with old
Method.add_method.

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

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

* 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

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

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

* Disposed old declarations, tactics, tactic combinators that refer to
the simpset or claset of an implicit theory (such as Addsimps,
Simp_tac, SIMPSET).  INCOMPATIBILITY, should use @{simpset} etc. in
embedded ML text, or local_simpset_of with a proper context passed as
explicit runtime argument.

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

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

* ML antiquotations: block-structured compilation context indicated by
\<lbrace> ... \<rbrace>; additional antiquotation forms:

  @{binding name}                         - basic name binding
  @{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 ***

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

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

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



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.