Isabelle NEWS -- history user-relevant changes

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

New in this Isabelle release

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

*** General ***

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

  theory <name>

  imports <theory1> ... <theoryN>

  uses <file1> ... <fileM>

  begin

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

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

will disappear in the next release.  Use isatool fixheaders to convert

existing theory files.  Note that there is no change in ancient

non-Isar theories now, but these are likely to disappear soon.

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

relative and absolute paths.

* Improved version of thms_containing searches for a list of criteria

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

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

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

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

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

simplification rules whose lhs match term.  Any other term is

interpreted as pattern and selects all theorems matching the

pattern. Available in ProofGeneral under 'ProofGeneral -> Find

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

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

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

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

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

*** Document preparation ***

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

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

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

displayed properly, everything else is left verbatim.  isatool display

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

DVI/PDF_VIEWER and PRINT_COMMAND settings, respectively).

* Command tags control specific markup of certain regions of text,

notably folding and hiding.  Predefined tags include "theory" (for

theory begin and end), "proof" for proof commands, and "ML" for

commands involving ML code; the additional tags "visible" and

"invisible" are unused by default.  Users may give explicit tag

specifications in the text, e.g. ''by %invisible (auto)''.  The

interpretation of tags is determined by the LaTeX job during document

preparation: see option -V of isatool usedir, or options -n and -t of

isatool document, or even the LaTeX macros \isakeeptag, \isafoldtag,

\isadroptag.

Several document versions may be produced at the same time via isatool

usedir (the generated index.html will link all of them).  Typical

specifications include ''-V document=theory,proof,ML'' to present

theory/proof/ML parts faithfully, ''-V outline=/proof,/ML'' to fold

proof and ML commands, and ''-V mutilated=-theory,-proof,-ML'' to omit

these parts without any formal replacement text.  The Isabelle site

default settings produce ''document'' and ''outline'' versions as

specified above.

* Several new antiquotation:

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

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

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

  argument is a known logical constant;

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

  theorem applying a "style" to it

  @{ML text}

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

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

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

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

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

document practical applications.  The ML antiquotation prints

type-checked ML expressions verbatim.

* Proper output of proof terms (@{prf ...} and @{full_prf ...}) within

a proof context.

* Proper output of antiquotations for theory commands involving a

proof context (such as 'locale' or 'theorem (in loc) ...').

*** Pure ***

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

automatic type-inference of declared constants; additional support for

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

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

sequential dependencies of definitions within a single 'constdefs'

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

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

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

indexed syntax provides a notational device for subscripted

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

expressions.  Secondly, in a local context with structure

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

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

show_structs controls printing of implicit structures.  Typical

applications of these concepts involve record types and locales.

* New command 'no_syntax' removes grammar declarations (and

translations) resulting from the given syntax specification, which is

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

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

on the signature of the theory context being presently used for

parsing/printing, see also isar-ref manual.

* Improved 'oracle' command provides a type-safe interface to turn an

ML expression of type theory -> T -> term into a primitive rule of

type theory -> T -> thm (i.e. the functionality of Thm.invoke_oracle

is already included here); see also FOL/ex/IffExample.thy;

INCOMPATIBILITY.

* Improved internal renaming of symbolic identifiers -- attach primes

instead of base 26 numbers.

* New flag show_question_marks controls printing of leading question

marks in schematic variable names.

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

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

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

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

    by simp

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

* Pretty pinter now supports unbreakable blocks, specified in mixfix

annotations as "(00...)".

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

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

Before that distinction was only partially implemented via type class

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

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

exotic syntax specifications may require further adaption

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

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

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

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

specifications.

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

locally fixed variables as well.

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

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

Limit.

* Simplifier: simplification procedures may now take the current

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

interface), which is very useful for calling the Simplifier

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

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

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

allow for use in a context of fixed variables.

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

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

the elimination rule contains !! or ==>.

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

from Pure, which contains all common declarations already.  Both

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

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

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

use isatool fixcpure to adapt your theory and ML sources.

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

selections of theorems in named facts via index ranges.

* More efficient treatment of intermediate checkpoints in interactive

theory development.

* 'print_theorems': in theory mode, really print the difference

wrt. the last state (works for interactive theory development only),

in proof mode print all local facts (cf. 'print_facts');

*** Locales ***

* New commands for the interpretation of locale expressions in theories (1),

locales (2) and proof contexts (3).  These generate proof obligations from

the expression specification.  After the obligations have been discharged,

theorems of the expression are added to the theory, target locale or proof

context.  The synopsis of the commands is a follows:

  (1) interpretation expr inst

  (2) interpretation target < expr

  (3) interpret expr inst

Interpretation in theories and proof contexts require a parameter

instantiation of terms from the current context.  This is applied to

specifications and theorems of the interpreted expression.  Interpretation

in locales only permits parameter renaming through the locale expression.

Interpretation is smart in that interpretations that are active already

do not occur in proof obligations, neither are instantiated theorems stored

in duplicate.  Use 'print_interps' to inspect active interpretations of

a particular locale.  For details, see the Isar Reference manual.

INCOMPATIBILITY: former 'instantiate' has been withdrawn, use

'interpret' instead.

* New context element 'constrains' for adding type constraints to parameters.

* Context expressions: renaming of parameters with syntax redeclaration.

* Locale declaration: 'includes' disallowed.

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

facts mentioned as arguments are always those of the locale definition

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

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

to attribute arguments as expected.

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

actual attributes; rare situations may require Attrib.attribute to

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

Attribute implementations need to cooperate properly with the static

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

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

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

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

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

values to argument tokens explicitly.

* Changed parameter management in theorem generation for long goal

statements with 'includes'.  INCOMPATIBILITY: produces a different

theorem statement in rare situations.

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

alternative context used for evaluating and printing the subsequent

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

*** Provers ***

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

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

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

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

still available as 'simplesubst'.

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

and quasi orders.

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

reflexive-transitive closure of relations.

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

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

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

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

initial simpset configuration as before.  INCOMPATIBILITY.

*** HOL ***

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

  syntax (epsilon)

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

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

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

Moreover, the mathematically important symbolic identifier \<epsilon>

becomes available as variable, constant etc.  INCOMPATIBILITY,

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

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

is \<ge>. New transitivity rules have been added to HOL/Orderings.thy to 

support corresponding Isar calculations.

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

instead of ":".

* theory SetInterval: changed the syntax for open intervals:

  Old       New

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

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

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

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

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

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

release.  For conversion use the following Emacs search and replace

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

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

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

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

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

now either "SUM x:A. e" or "\<Sum>x \<in> A. e". The bound variable can 

be a tuple pattern.

Some new syntax forms are available:

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

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

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

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

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

function "Summation", which has been discontinued.

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

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

(insert F x)'.

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

fragment of HOL, including axiomatic type classes, constdefs and

typedefs, inductive datatypes and recursion.

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

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

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

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

in unstructured proof scripts.

* Reworked implementation of records.  Improved scalability for

records with many fields, avoiding performance problems for type

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

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

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

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

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

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

<record_name>_ext_type.

Flag record_quick_and_dirty_sensitive can be enabled to skip the

proofs triggered by a record definition or a simproc (if

quick_and_dirty is enabled).  Definitions of large records can take

quite long.

New simproc record_upd_simproc for simplification of multiple record

updates enabled by default.  Moreover, trivial updates are also

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

occasionally, since simplification is more powerful by default.

* Simplifier: automatically reasons about transitivity chains

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

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

old proofs break occasionally as simplification may now solve more

goals than previously.

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

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

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

just like y <= x.

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

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

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

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

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

enabled/disabled by the reference use_let_simproc.  Potential

INCOMPATIBILITY since simplification is more powerful by default.

* Classical reasoning: the meson method now accepts theorems as arguments.

* Theory OrderedGroup and Ring_and_Field: various additions and

improvements to faciliate calculations involving equalities and

inequalities.

The following theorems have been eliminated or modified

(INCOMPATIBILITY):

  abs_eq             now named abs_of_nonneg

  abs_of_ge_0        now named abs_of_nonneg 

  abs_minus_eq       now named abs_of_nonpos  

  imp_abs_id         now named abs_of_nonneg

  imp_abs_neg_id     now named abs_of_nonpos

  mult_pos           now named mult_pos_pos

  mult_pos_le        now named mult_nonneg_nonneg

  mult_pos_neg_le    now named mult_nonneg_nonpos

  mult_pos_neg2_le   now named mult_nonneg_nonpos2

  mult_neg           now named mult_neg_neg

  mult_neg_le        now named mult_nonpos_nonpos

* Theory Parity: added rules for simplifying exponents.

* Theory List:

The following theorems have been eliminated or modified

(INCOMPATIBILITY):

  list_all_Nil       now named list_all.simps(1)

  list_all_Cons      now named list_all.simps(2)

  list_all_conv      now named list_all_iff

  set_mem_eq         now named mem_iff

* Theories SetsAndFunctions and BigO (see HOL/Library) support

asymptotic "big O" calculations.  See the notes in BigO.thy.

*** HOL-Complex ***

* Theory RealDef: better support for embedding natural numbers and

integers in the reals.

The following theorems have been eliminated or modified

(INCOMPATIBILITY):

  exp_ge_add_one_self  now requires no hypotheses

  real_of_int_add      reversed direction of equality (use [symmetric])

  real_of_int_minus    reversed direction of equality (use [symmetric])

  real_of_int_diff     reversed direction of equality (use [symmetric])

  real_of_int_mult     reversed direction of equality (use [symmetric])

* Theory RComplete: expanded support for floor and ceiling functions.

* Theory Ln is new, with properties of the natural logarithm

*** HOLCF ***

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

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

full type-inference.

*** ZF ***

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

including the First Isomorphism Theorem (on quotienting by the kernel

of a homomorphism).

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

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

the old version is still required for ML proof scripts.

*** ML ***

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

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

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

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

accordingly, while Option.map replaces apsome.

* Pure/library.ML: the exception LIST has been given up in favour of

the standard exceptions Empty and Subscript, as well as

Library.UnequalLengths.  Function like Library.hd and Library.tl are

superceded by the standard hd and tl functions etc.

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

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

suggests how one can translate existing code:

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

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

    last_elem xs = List.last xs

    flat xss = List.concat xss

    seq fs = List.app fs

    partition P xs = List.partition P xs

    mapfilter f xs = List.mapPartial f xs

* Pure/library.ML: several combinators for linear functional

transformations, notably reverse application and composition:

  x |> f		f #> g

  (x, y) |-> f		f #-> g

* Pure/library.ML: canonical list combinators fold, fold_rev, and

fold_map support linear functional transformations and nesting.  For

example:

  fold f [x1, ..., xN] y =

    y |> f x1 |> ... |> f xN

  (fold o fold) f [xs1, ..., xsN] y =

    y |> fold f xs1 |> ... |> fold f xsN

  fold f [x1, ..., xN] =

    f x1 #> ... #> f xN

  (fold o fold) f [xs1, ..., xsN] =

    fold f xs1 #> ... #> fold f xsN

* Pure/term.ML: combinators fold_atyps, fold_aterms, fold_term_types,

fold_types traverse types/terms from left to right, observing

canonical argument order.  Supercedes previous foldl_XXX versions,

add_frees, add_vars etc. have been adapted as well: INCOMPATIBILITY.

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

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

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

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

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

result of Pretty.string_of/str_of and derived functions

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

easy composition of diagnostic messages etc.  Programmers rarely need

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

exceptions: Output.output is required when bypassing the standard

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

formatted results; Output.raw is required when capturing already

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

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

have no effect.

* Pure: Output.time_accumulator NAME creates an operator ('a -> 'b) ->

'a -> 'b to measure runtime and count invocations; the cumulative

results are displayed at the end of a batch session.

* Isar toplevel: improved diagnostics, mostly for Poly/ML only.

Reference Toplevel.debug (default false) controls detailed printing

and tracing of low-level exceptions; Toplevel.profiling (default 0)

controls execution profiling -- set to 1 for time and 2 for space

(both increase the runtime).

* Isar session: The initial use of ROOT.ML is now always timed,

i.e. the log will show the actual process times, in contrast to the

elapsed wall-clock time that the outer shell wrapper produces.

* Pure: structure OrdList (cf. Pure/General/ord_list.ML) provides a

reasonably efficient light-weight implementation of sets as lists.

* Pure: more efficient orders for basic syntactic entities: added

fast_string_ord, fast_indexname_ord, fast_term_ord; changed sort_ord

and typ_ord to use fast_string_ord and fast_indexname_ord (term_ord is

NOT affected); structures Symtab, Vartab, Typtab, Termtab use the fast

orders now -- potential INCOMPATIBILITY for code that depends on a

particular order for Symtab.keys, Symtab.dest, etc. (consider using

Library.sort_strings on result).

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

internal interfaces -- INCOMPATIBILITY.  Renamed cond_extern(_table)

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

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

a fully qualified name and external accesses of a fully qualified

name; NameSpace.extend is superceded by context dependent

Sign.declare_name.  Several theory and proof context operations modify

the naming context.  Especially note Theory.restore_naming and

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

Theory.add_path is no longer sufficient to recover from

Theory.absolute_path in particular.

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

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

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

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

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

with earlier declarations.

* Pure/TheoryDataFun: change of the argument structure; 'prep_ext' is

now 'extend', and 'merge' gets an additional Pretty.pp argument

(useful for printing error messages).  INCOMPATIBILITY.

* Pure: major reorganization of the theory context.  Type Sign.sg and

Theory.theory are now identified, referring to the universal

Context.theory (see Pure/context.ML).  Actual signature and theory

content is managed as theory data.  The old code and interfaces were

spread over many files and structures; the new arrangement introduces

considerable INCOMPATIBILITY to gain more clarity:

  Context -- theory management operations (name, identity, inclusion,

    parents, ancestors, merge, etc.), plus generic theory data;

  Sign -- logical signature and syntax operations (declaring consts,

    types, etc.), plus certify/read for common entities;

  Theory -- logical theory operations (stating axioms, definitions,

    oracles), plus a copy of logical signature operations (consts,

    types, etc.); also a few basic management operations (Theory.copy,

    Theory.merge, etc.)

The most basic sign_of operations (Theory.sign_of, Thm.sign_of_thm

etc.) as well as the sign field in Thm.rep_thm etc. have been retained

for convenience -- they merely return the theory.

* Pure: the Isar proof context type is already defined early in Pure

as Context.proof (note that ProofContext.context and Proof.context are

aliases, where the latter is the preferred name).  This enables other

Isabelle components to refer to that type even before Isar is present.

* Pure/sign/theory: discontinued named name spaces (i.e. classK,

typeK, constK, axiomK, oracleK), but provide explicit operations for

any of these kinds.  For example, Sign.intern typeK is now

Sign.intern_type, Theory.hide_space Sign.typeK is now

Theory.hide_types.  Also note that former

Theory.hide_classes/types/consts are now

Theory.hide_classes_i/types_i/consts_i, while the non '_i' versions

internalize their arguments!  INCOMPATIBILITY.

* Pure: get_thm interface (of PureThy and ProofContext) expects

datatype thmref (with constructors Name and NameSelection) instead of

plain string -- INCOMPATIBILITY;

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

means to remove case bindings -- INCOMPATIBILITY in

(RAW_)METHOD_CASES.

* Pure: the following operations retrieve axioms or theorems from a

theory node or theory hierarchy, respectively:

  Theory.axioms_of: theory -> (string * term) list

  Theory.all_axioms_of: theory -> (string * term) list

  PureThy.thms_of: theory -> (string * thm) list

  PureThy.all_thms_of: theory -> (string * thm) list

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

* Pure/Simplifier: improved handling of bound variables (nameless

representation, avoid allocating new strings).  Simprocs that invoke

the Simplifier recursively should use Simplifier.inherit_bounds to

avoid local name clashes.

* Pure/Provers: Simplifier and Classical Reasoner now support proof

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

extra components are stored in the theory and patched into the

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

components are maintained by the following theory operations:

  Simplifier.add_context_simprocs

  Simplifier.del_context_simprocs

  Simplifier.set_context_subgoaler

  Simplifier.reset_context_subgoaler

  Simplifier.add_context_looper

  Simplifier.del_context_looper

  Simplifier.add_context_unsafe_solver

  Simplifier.add_context_safe_solver

  Classical.add_context_safe_wrapper

  Classical.del_context_safe_wrapper

  Classical.add_context_unsafe_wrapper

  Classical.del_context_unsafe_wrapper

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

local_simpset_of and local_claset_of to instead of the primitive

Simplifier.get_local_simpset and Classical.get_local_claset,

respectively, in order to see the context dependent fields!

* File.sysify_path and File.quote_sysify path have been replaced by

File.platform_path and File.shell_path (with appropriate hooks).  This

provides a clean interface for unusual systems where the internal and

external process view of file names are different.

* ML functions legacy_bindings and use_legacy_bindings produce ML fact

bindings for all theorems stored within a given theory; this may help

in porting non-Isar theories to Isar ones, while keeping ML proof

scripts for the time being.

*** System ***

* Allow symlinks to all proper Isabelle executables (Isabelle,

isabelle, isatool etc.).

* ISABELLE_DOC_FORMAT setting specifies preferred document format (for

isatool doc, isatool mkdir, display_drafts etc.).

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

used by Isabelle; default is ROOT.ML.

* New isatool version outputs the version identifier of the Isabelle

distribution being used.

* HOL: new isatool dimacs2hol converts files in DIMACS CNF format

(containing Boolean satisfiability problems) into Isabelle/HOL

theories.

New in Isabelle2004 (April 2004)

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

*** General ***

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

  Replaces linorder.ML.

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

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

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

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

  now. COMPATIBILITY: This obviously changes the parsing of some

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

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

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

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

  existing theory and ML files.

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

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

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

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

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

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

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

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

  superscript. The new control characters are not identifier parts.

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

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

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

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

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

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

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

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

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

  (i.e. intersections of classes),

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

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

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

*** Isar ***

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

  cut_tac, subgoal_tac and thin_tac:

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

    locales are no longer forced to write Isar proof scripts.

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

    emulations.

  - INCOMPATIBILITY: names of variables to be instantiated may no

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

    This is consistent with the instantiation attribute "where".

* Attributes "where" and "of":

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

    the instantiation string.  This fixes a bug that caused instantiated

    theorems to have too special types in some circumstances.

  - "where" permits explicit instantiations of type variables.

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

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

  and derived forms.

* Locales:

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

    generate theorems with internal delta predicates (those ending on

    "_axioms") in the premise.

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

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

    specification and "includes" elements in goal statement.

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

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

  - Experimental command for instantiation of locales in proof contexts:

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

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

    taking into account their attributes.  Label and attrs are optional

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

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

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

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

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

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

    with "locale (open)".

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

* HOL: Tactic emulation methods induct_tac and case_tac understand static

  (Isar) contexts.

*** HOL ***

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

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

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

  can be used like any other Isabelle image.  See

  HOL/Import/HOL/README for more information.

* Simplifier:

  - Much improved handling of linear and partial orders.

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

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

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

    to solve goals from the assumptions.

  - INCOMPATIBILITY: old proofs break occasionally.  Typically, applications

    of blast or auto after simplification become unnecessary because the goal

    is solved by simplification already.

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

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

* Numerics:

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

    now formalized using the Ring_and_Field theory mentioned above.

  - INCOMPATIBILITY: simplification and arithmetic behaves somewhat differently

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

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

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

    exponentiation).

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

* Records:

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

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

    the reference "print_record_type_abbr".

  - Simproc "record_upd_simproc" for simplification of multiple updates added

    (not enabled by default).

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

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

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

* 'specification' command added, allowing for definition by

  specification.  There is also an 'ax_specification' command that

  introduces the new constants axiomatically.

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

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

* HOL-ex: InductiveInvariant_examples illustrates advanced recursive function

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

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

  matrix theory to linear programming.

* Unions and Intersections:

  The latex output syntax of UN and INT has been changed

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

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

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

* Unions and Intersections over Intervals:

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

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

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

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

  lexicographic dictonary ordering has been added as "lexord".

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

  conflicted with ML Basis Library structures having the same names.

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

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

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

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

  formulae under an assignment of free variables to random values.

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

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

  for examples.

*** HOLCF ***

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

New in Isabelle2003 (May 2003)

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

*** General ***

* Provers/simplifier:

  - Completely reimplemented method simp (ML: Asm_full_simp_tac):

    Assumptions are now subject to complete mutual simplification,

    not just from left to right. The simplifier now preserves

    the order of assumptions.

    Potential INCOMPATIBILITY:

    -- simp sometimes diverges where the old version did

       not, e.g. invoking simp on the goal

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

       now gives rise to the infinite reduction sequence

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

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

       kind of problem.

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

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

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

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

       in case of problems. Sometimes subsequent calls to the classical

       reasoner will fail because a preceeding call to the simplifier too

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

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

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

    during conditional rewriting (where the simplifie tries to solve the

    conditions before applying the rewrite rule):

    ML "simp_depth_limit := n"

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

    the simplifier would diverge.

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

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

    congruence is ignored.

* Pure: New generic framework for extracting programs from constructive

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

  as HOL/Extraction for some case studies.

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

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

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

(ML: Proof.show_main_goal).

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

rules whose conclusion matches subgoal 1:

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

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

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

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

(ML: ProofGeneral.print_intros())

* Pure: New flag trace_unify_fail causes unification to print

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

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

assumption failed.

* Pure: Locale specifications now produce predicate definitions

according to the body of text (covering assumptions modulo local

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

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

latter view is presented only on export into the global theory

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

on the old view without predicates;

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

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

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

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

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

include local facts of proof configuration (also covers active

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

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

be given (the default is 40);

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

(batch-mode only);

* Provers: improved induct method: assumptions introduced by case

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

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

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

are regarded as potentially overloaded, which improves robustness in exchange

for slight decrease in efficiency;

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

linear orders.  Note: this prover is not efficient!

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

rather than just a warning (in interactive mode);

*** HOL ***

* arith(_tac)

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

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

   of quantifier-free linear arithmetic.

   In ProofGeneral the counter example appears in the trace buffer.

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