Isabelle NEWS -- history user-relevant changes

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

New in this Isabelle version

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

*** 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 "Isabelle" alias for "isabelle-interface" has been removed.

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

Also note that user interfaces are now better wrapped as regular

Isabelle tools instead of using the special isabelle-interface wrapper

(which can be confusing if the interface is uninstalled or changed

otherwise).  See "isabelle tty" and "isabelle emacs" for contemporary

examples.

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 Isabelle System Manual (system) has been updated, with formally

checked references as hyperlinks.

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

*** Pure ***

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

  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.

  INCOMPATIBILITY.

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

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

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

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

* 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 one time 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.).  See also

ISABELLE_HOME/contrib/SystemOnTPTP and the VAMPIRE_HOME setting

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

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

* 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

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

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

*** ML ***

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

* Name bindings in higher specification mechanisms (notably

LocalTheory.define, LocalTheory.note, and derived packages) are now

formalized as type Name.binding, replacing old bstring.

INCOMPATIBILITY, need to wrap strings via Name.binding function, see

also Name.name_of.  Packages should pass name bindings given by the

user to underlying specification mechanisms; this enables precise

tracking of source positions, for example.

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

* Theory Finite_Set: locales ACf, ACe, ACIf, ACIfSL and ACIfSLlin

(whose purpose mainly is for various fold_set functionals) have been

abandoned in favor of the existing algebraic classes

ab_semigroup_mult, comm_monoid_mult, ab_semigroup_idem_mult,

lower_semilattice (resp. upper_semilattice) and linorder.

INCOMPATIBILITY.

* Theory Transitive_Closure: induct and cases rules now declare proper

case_names ("base" and "step").  INCOMPATIBILITY.

* Theorem Inductive.lfp_ordinal_induct generalized to complete

lattices.  The form set-specific version is available as

Inductive.lfp_ordinal_induct_set.

* Renamed theorems "power.simps" to "power_int.simps".

INCOMPATIBILITY.

* Class semiring_div provides basic abstract properties of semirings

with division and modulo operations.  Subsumes former class dvd_mod.

* Merged theories IntDef, Numeral and IntArith into unified theory

Int.  INCOMPATIBILITY.

* Theory Library/Code_Index: type "index" now represents natural

numbers rather than integers.  INCOMPATIBILITY.

* New class "uminus" with operation "uminus" (split of from class

"minus" which now only has operation "minus", binary).

INCOMPATIBILITY.

* Constants "card", "internal_split", "option_map" now with authentic

syntax.  INCOMPATIBILITY.

* Definitions subset_def, psubset_def, set_diff_def, Compl_def,

le_bool_def, less_bool_def, le_fun_def, less_fun_def, inf_bool_def,

sup_bool_def, Inf_bool_def, Sup_bool_def, inf_fun_def, sup_fun_def,

Inf_fun_def, Sup_fun_def, inf_set_def, sup_set_def, Inf_set_def,

Sup_set_def, le_def, less_def, option_map_def now with object

equality.  INCOMPATIBILITY.

* Records. Removed K_record, and replaced it by pure lambda term

%x. c. The simplifier setup is now more robust against eta expansion.

INCOMPATIBILITY: in cases explicitly referring to K_record.

* Library/Multiset: {#a, b, c#} abbreviates {#a#} + {#b#} + {#c#}.

* Library/ListVector: new theory of arithmetic vector operations.

* Library/Order_Relation: new theory of various orderings as sets of

pairs.  Defines preorders, partial orders, linear orders and

well-orders on sets and on types.

*** ZF ***

* Renamed some theories to allow to loading both ZF and HOL in the

same session:

  Datatype  -> Datatype_ZF

  Inductive -> Inductive_ZF

  Int       -> Int_ZF

  IntDiv    -> IntDiv_ZF

  Nat       -> Nat_ZF

  List      -> List_ZF

  Main      -> Main_ZF

INCOMPATIBILITY: ZF theories that import individual theories below

Main might need to be adapted.  Regular theory Main is still

available, as trivial extension of Main_ZF.

*** ML ***

* ML within Isar: antiquotation @{const name} or @{const

name(typargs)} produces statically-checked Const term.

* Functor NamedThmsFun: data is available to the user as dynamic fact

(of the same name).  Removed obsolete print command.

* Removed obsolete "use_legacy_bindings" function.

* The ``print mode'' is now a thread-local value derived from a global

template (the former print_mode reference), thus access becomes

non-critical.  The global print_mode reference is for session

management only; user-code should use print_mode_value,

print_mode_active, PrintMode.setmp etc.  INCOMPATIBILITY.

* Functions system/system_out provide a robust way to invoke external

shell commands, with propagation of interrupts (requires Poly/ML 5.2).

Do not use OS.Process.system etc. from the basis library!

*** System ***

* Default settings: PROOFGENERAL_OPTIONS no longer impose xemacs ---

in accordance with Proof General 3.7, which prefers GNU emacs.

* isatool tty runs Isabelle process with plain tty interaction;

optional line editor may be specified via ISABELLE_LINE_EDITOR

setting, the default settings attempt to locate "ledit" and "rlwrap".

* isatool browser now works with Cygwin as well, using general

"javapath" function defined in Isabelle process environment.

* YXML notation provides a simple and efficient alternative to

standard XML transfer syntax.  See src/Pure/General/yxml.ML and

isatool yxml as described in the Isabelle system manual.

* JVM class isabelle.IsabelleProcess (located in Isabelle/lib/classes)

provides general wrapper for managing an Isabelle process in a robust

fashion, with ``cooked'' output from stdin/stderr.

* Rudimentary Isabelle plugin for jEdit (see Isabelle/lib/jedit),

based on Isabelle/JVM process wrapper (see Isabelle/lib/classes).

* Removed obsolete THIS_IS_ISABELLE_BUILD feature.  NB: the documented

way of changing the user's settings is via

ISABELLE_HOME_USER/etc/settings, which is a fully featured bash

script.

* Multithreading.max_threads := 0 refers to the number of actual CPU

cores of the underlying machine, which is a good starting point for

optimal performance tuning.  The corresponding usedir option -M allows

"max" as an alias for "0".  WARNING: does not work on certain versions

of Mac OS (with Poly/ML 5.1).

* isabelle-process: non-ML sessions are run with "nice", to reduce the

adverse effect of Isabelle flooding interactive front-ends (notably

ProofGeneral / XEmacs).

New in Isabelle2007 (November 2007)

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

*** General ***

* More uniform information about legacy features, notably a

warning/error of "Legacy feature: ...", depending on the state of the

tolerate_legacy_features flag (default true). FUTURE INCOMPATIBILITY:

legacy features will disappear eventually.

* Theory syntax: the header format ``theory A = B + C:'' has been

discontinued in favour of ``theory A imports B C begin''.  Use isatool

fixheaders to convert existing theory files.  INCOMPATIBILITY.

* Theory syntax: the old non-Isar theory file format has been

discontinued altogether.  Note that ML proof scripts may still be used

with Isar theories; migration is usually quite simple with the ML

function use_legacy_bindings.  INCOMPATIBILITY.

* Theory syntax: some popular names (e.g. 'class', 'declaration',

'fun', 'help', 'if') are now keywords.  INCOMPATIBILITY, use double

quotes.

* Theory loader: be more serious about observing the static theory

header specifications (including optional directories), but not the

accidental file locations of previously successful loads.  The strict

update policy of former update_thy is now already performed by

use_thy, so the former has been removed; use_thys updates several

theories simultaneously, just as 'imports' within a theory header

specification, but without merging the results.  Potential

INCOMPATIBILITY: may need to refine theory headers and commands

ROOT.ML which depend on load order.

* Theory loader: optional support for content-based file

identification, instead of the traditional scheme of full physical

path plus date stamp; configured by the ISABELLE_FILE_IDENT setting

(cf. the system manual).  The new scheme allows to work with

non-finished theories in persistent session images, such that source

files may be moved later on without requiring reloads.

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

file (with the same base name as the theory) are considered a legacy

feature, which will disappear eventually. Even now, the theory loader

no longer maintains dependencies on such files.

* Syntax: the scope for resolving ambiguities via type-inference is

now limited to individual terms, instead of whole simultaneous

specifications as before. This greatly reduces the complexity of the

syntax module and improves flexibility by separating parsing and

type-checking. INCOMPATIBILITY: additional type-constraints (explicit

'fixes' etc.) are required in rare situations.

* Syntax: constants introduced by new-style packages ('definition',

'abbreviation' etc.) are passed through the syntax module in

``authentic mode''. This means that associated mixfix annotations

really stick to such constants, independently of potential name space

ambiguities introduced later on. INCOMPATIBILITY: constants in parse

trees are represented slightly differently, may need to adapt syntax

translations accordingly. Use CONST marker in 'translations' and

@{const_syntax} antiquotation in 'parse_translation' etc.

* Legacy goal package: reduced interface to the bare minimum required

to keep existing proof scripts running.  Most other user-level

functions are now part of the OldGoals structure, which is *not* open

by default (consider isatool expandshort before open OldGoals).

Removed top_sg, prin, printyp, pprint_term/typ altogether, because

these tend to cause confusion about the actual goal (!) context being

used here, which is not necessarily the same as the_context().

* Command 'find_theorems': supports "*" wild-card in "name:"

criterion; "with_dups" option.  Certain ProofGeneral versions might

support a specific search form (see ProofGeneral/CHANGES).

* The ``prems limit'' option (cf. ProofContext.prems_limit) is now -1

by default, which means that "prems" (and also "fixed variables") are

suppressed from proof state output.  Note that the ProofGeneral

settings mechanism allows to change and save options persistently, but

older versions of Isabelle will fail to start up if a negative prems

limit is imposed.

* Local theory targets may be specified by non-nested blocks of

``context/locale/class ... begin'' followed by ``end''.  The body may

contain definitions, theorems etc., including any derived mechanism

that has been implemented on top of these primitives.  This concept

generalizes the existing ``theorem (in ...)'' towards more versatility

and scalability.

* Proof General interface: proper undo of final 'end' command;

discontinued Isabelle/classic mode (ML proof scripts).

*** Document preparation ***

* Added antiquotation @{theory name} which prints the given name,

after checking that it refers to a valid ancestor theory in the

current context.

* Added antiquotations @{ML_type text} and @{ML_struct text} which

check the given source text as ML type/structure, printing verbatim.

* Added antiquotation @{abbrev "c args"} which prints the abbreviation

"c args == rhs" given in the current context.  (Any number of

arguments may be given on the LHS.)

*** Pure ***

* The 'class' package offers a combination of axclass and locale to

achieve Haskell-like type classes in Isabelle.  Definitions and

theorems within a class context produce both relative results (with

implicit parameters according to the locale context), and polymorphic

constants with qualified polymorphism (according to the class

context).  Within the body context of a 'class' target, a separate

syntax layer ("user space type system") takes care of converting

between global polymorphic consts and internal locale representation.

See src/HOL/ex/Classpackage.thy for examples (as well as main HOL).

"isatool doc classes" provides a tutorial.

* Generic code generator framework allows to generate executable

code for ML and Haskell (including Isabelle classes).  A short usage

sketch:

    internal compilation:

        export_code <list of constants (term syntax)> in SML

    writing SML code to a file:

        export_code <list of constants (term syntax)> in SML <filename>

    writing OCaml code to a file:

        export_code <list of constants (term syntax)> in OCaml <filename>

    writing Haskell code to a bunch of files:

        export_code <list of constants (term syntax)> in Haskell <filename>

    evaluating closed propositions to True/False using code generation:

        method ``eval''

Reasonable default setup of framework in HOL.

Theorem attributs for selecting and transforming function equations theorems:

    [code fun]:        select a theorem as function equation for a specific constant

    [code fun del]:    deselect a theorem as function equation for a specific constant

    [code inline]:     select an equation theorem for unfolding (inlining) in place

    [code inline del]: deselect an equation theorem for unfolding (inlining) in place

User-defined serializations (target in {SML, OCaml, Haskell}):

    code_const <and-list of constants (term syntax)>

      {(target) <and-list of const target syntax>}+

    code_type <and-list of type constructors>

      {(target) <and-list of type target syntax>}+

    code_instance <and-list of instances>

      {(target)}+

        where instance ::= <type constructor> :: <class>

    code_class <and_list of classes>

      {(target) <and-list of class target syntax>}+

        where class target syntax ::= <class name> {where {<classop> == <target syntax>}+}?

code_instance and code_class only are effective to target Haskell.

For example usage see src/HOL/ex/Codegenerator.thy and

src/HOL/ex/Codegenerator_Pretty.thy.  A separate tutorial on code

generation from Isabelle/HOL theories is available via "isatool doc

codegen".

* Code generator: consts in 'consts_code' Isar commands are now

referred to by usual term syntax (including optional type

annotations).

* Command 'no_translations' removes translation rules from theory

syntax.

* Overloaded definitions are now actually checked for acyclic

dependencies.  The overloading scheme is slightly more general than

that of Haskell98, although Isabelle does not demand an exact

correspondence to type class and instance declarations.

INCOMPATIBILITY, use ``defs (unchecked overloaded)'' to admit more