more symbols;
authorwenzelm
Wed Oct 14 15:10:32 2015 +0200 (2015-10-14)
changeset 614392bf52eec4e8a
parent 61438 151f894984d8
child 61440 8626c2fed037
more symbols;
src/Doc/Implementation/Eq.thy
src/Doc/Implementation/Integration.thy
src/Doc/Implementation/Isar.thy
src/Doc/Implementation/Local_Theory.thy
src/Doc/Implementation/Logic.thy
src/Doc/Implementation/ML.thy
src/Doc/Implementation/Prelim.thy
src/Doc/Implementation/Proof.thy
src/Doc/Implementation/Syntax.thy
src/Doc/Implementation/Tactic.thy
src/Doc/Isar_Ref/Document_Preparation.thy
src/Doc/Isar_Ref/Generic.thy
src/Doc/Isar_Ref/HOL_Specific.thy
src/Doc/Isar_Ref/Inner_Syntax.thy
src/Doc/Isar_Ref/Outer_Syntax.thy
src/Doc/Isar_Ref/Proof.thy
src/Doc/Isar_Ref/Proof_Script.thy
src/Doc/Isar_Ref/Spec.thy
src/Doc/JEdit/JEdit.thy
src/Doc/System/Basics.thy
src/Doc/System/Misc.thy
src/Doc/System/Sessions.thy
     1.1 --- a/src/Doc/Implementation/Eq.thy	Wed Oct 14 15:06:42 2015 +0200
     1.2 +++ b/src/Doc/Implementation/Eq.thy	Wed Oct 14 15:10:32 2015 +0200
     1.3 @@ -100,21 +100,21 @@
     1.4  
     1.5    \begin{description}
     1.6  
     1.7 -  \item @{ML rewrite_rule}~@{text "ctxt rules thm"} rewrites the whole
     1.8 +  \<^descr> @{ML rewrite_rule}~@{text "ctxt rules thm"} rewrites the whole
     1.9    theorem by the given rules.
    1.10  
    1.11 -  \item @{ML rewrite_goals_rule}~@{text "ctxt rules thm"} rewrites the
    1.12 +  \<^descr> @{ML rewrite_goals_rule}~@{text "ctxt rules thm"} rewrites the
    1.13    outer premises of the given theorem.  Interpreting the same as a
    1.14    goal state (\secref{sec:tactical-goals}) it means to rewrite all
    1.15    subgoals (in the same manner as @{ML rewrite_goals_tac}).
    1.16  
    1.17 -  \item @{ML rewrite_goal_tac}~@{text "ctxt rules i"} rewrites subgoal
    1.18 +  \<^descr> @{ML rewrite_goal_tac}~@{text "ctxt rules i"} rewrites subgoal
    1.19    @{text "i"} by the given rewrite rules.
    1.20  
    1.21 -  \item @{ML rewrite_goals_tac}~@{text "ctxt rules"} rewrites all subgoals
    1.22 +  \<^descr> @{ML rewrite_goals_tac}~@{text "ctxt rules"} rewrites all subgoals
    1.23    by the given rewrite rules.
    1.24  
    1.25 -  \item @{ML fold_goals_tac}~@{text "ctxt rules"} essentially uses @{ML
    1.26 +  \<^descr> @{ML fold_goals_tac}~@{text "ctxt rules"} essentially uses @{ML
    1.27    rewrite_goals_tac} with the symmetric form of each member of @{text
    1.28    "rules"}, re-ordered to fold longer expression first.  This supports
    1.29    to idea to fold primitive definitions that appear in expended form
     2.1 --- a/src/Doc/Implementation/Integration.thy	Wed Oct 14 15:06:42 2015 +0200
     2.2 +++ b/src/Doc/Implementation/Integration.thy	Wed Oct 14 15:10:32 2015 +0200
     2.3 @@ -46,22 +46,22 @@
     2.4  
     2.5    \begin{description}
     2.6  
     2.7 -  \item Type @{ML_type Toplevel.state} represents Isar toplevel
     2.8 +  \<^descr> Type @{ML_type Toplevel.state} represents Isar toplevel
     2.9    states, which are normally manipulated through the concept of
    2.10    toplevel transitions only (\secref{sec:toplevel-transition}).
    2.11  
    2.12 -  \item @{ML Toplevel.UNDEF} is raised for undefined toplevel
    2.13 +  \<^descr> @{ML Toplevel.UNDEF} is raised for undefined toplevel
    2.14    operations.  Many operations work only partially for certain cases,
    2.15    since @{ML_type Toplevel.state} is a sum type.
    2.16  
    2.17 -  \item @{ML Toplevel.is_toplevel}~@{text "state"} checks for an empty
    2.18 +  \<^descr> @{ML Toplevel.is_toplevel}~@{text "state"} checks for an empty
    2.19    toplevel state.
    2.20  
    2.21 -  \item @{ML Toplevel.theory_of}~@{text "state"} selects the
    2.22 +  \<^descr> @{ML Toplevel.theory_of}~@{text "state"} selects the
    2.23    background theory of @{text "state"}, it raises @{ML Toplevel.UNDEF}
    2.24    for an empty toplevel state.
    2.25  
    2.26 -  \item @{ML Toplevel.proof_of}~@{text "state"} selects the Isar proof
    2.27 +  \<^descr> @{ML Toplevel.proof_of}~@{text "state"} selects the Isar proof
    2.28    state if available, otherwise it raises an error.
    2.29  
    2.30    \end{description}
    2.31 @@ -74,7 +74,7 @@
    2.32  
    2.33    \begin{description}
    2.34  
    2.35 -  \item @{text "@{Isar.state}"} refers to Isar toplevel state at that
    2.36 +  \<^descr> @{text "@{Isar.state}"} refers to Isar toplevel state at that
    2.37    point --- as abstract value.
    2.38  
    2.39    This only works for diagnostic ML commands, such as @{command
    2.40 @@ -123,27 +123,27 @@
    2.41  
    2.42    \begin{description}
    2.43  
    2.44 -  \item @{ML Toplevel.keep}~@{text "tr"} adjoins a diagnostic
    2.45 +  \<^descr> @{ML Toplevel.keep}~@{text "tr"} adjoins a diagnostic
    2.46    function.
    2.47  
    2.48 -  \item @{ML Toplevel.theory}~@{text "tr"} adjoins a theory
    2.49 +  \<^descr> @{ML Toplevel.theory}~@{text "tr"} adjoins a theory
    2.50    transformer.
    2.51  
    2.52 -  \item @{ML Toplevel.theory_to_proof}~@{text "tr"} adjoins a global
    2.53 +  \<^descr> @{ML Toplevel.theory_to_proof}~@{text "tr"} adjoins a global
    2.54    goal function, which turns a theory into a proof state.  The theory
    2.55    may be changed before entering the proof; the generic Isar goal
    2.56    setup includes an @{verbatim after_qed} argument that specifies how to
    2.57    apply the proven result to the enclosing context, when the proof
    2.58    is finished.
    2.59  
    2.60 -  \item @{ML Toplevel.proof}~@{text "tr"} adjoins a deterministic
    2.61 +  \<^descr> @{ML Toplevel.proof}~@{text "tr"} adjoins a deterministic
    2.62    proof command, with a singleton result.
    2.63  
    2.64 -  \item @{ML Toplevel.proofs}~@{text "tr"} adjoins a general proof
    2.65 +  \<^descr> @{ML Toplevel.proofs}~@{text "tr"} adjoins a general proof
    2.66    command, with zero or more result states (represented as a lazy
    2.67    list).
    2.68  
    2.69 -  \item @{ML Toplevel.end_proof}~@{text "tr"} adjoins a concluding
    2.70 +  \<^descr> @{ML Toplevel.end_proof}~@{text "tr"} adjoins a concluding
    2.71    proof command, that returns the resulting theory, after applying the
    2.72    resulting facts to the target context.
    2.73  
    2.74 @@ -177,11 +177,11 @@
    2.75  
    2.76    \begin{description}
    2.77  
    2.78 -  \item @{ML use_thy}~@{text A} ensures that theory @{text A} is fully
    2.79 +  \<^descr> @{ML use_thy}~@{text A} ensures that theory @{text A} is fully
    2.80    up-to-date wrt.\ the external file store; outdated ancestors are reloaded on
    2.81    demand.
    2.82  
    2.83 -  \item @{ML use_thys} is similar to @{ML use_thy}, but handles several
    2.84 +  \<^descr> @{ML use_thys} is similar to @{ML use_thy}, but handles several
    2.85    theories simultaneously. Thus it acts like processing the import header of a
    2.86    theory, without performing the merge of the result. By loading a whole
    2.87    sub-graph of theories, the intrinsic parallelism can be exploited by the
    2.88 @@ -189,14 +189,14 @@
    2.89  
    2.90    This variant is used by default in @{tool build} @{cite "isabelle-system"}.
    2.91  
    2.92 -  \item @{ML Thy_Info.get_theory}~@{text A} retrieves the theory value
    2.93 +  \<^descr> @{ML Thy_Info.get_theory}~@{text A} retrieves the theory value
    2.94    presently associated with name @{text A}. Note that the result might be
    2.95    outdated wrt.\ the file-system content.
    2.96  
    2.97 -  \item @{ML Thy_Info.remove_thy}~@{text A} deletes theory @{text A} and all
    2.98 +  \<^descr> @{ML Thy_Info.remove_thy}~@{text A} deletes theory @{text A} and all
    2.99    descendants from the theory database.
   2.100  
   2.101 -  \item @{ML Thy_Info.register_thy}~@{text "text thy"} registers an existing
   2.102 +  \<^descr> @{ML Thy_Info.register_thy}~@{text "text thy"} registers an existing
   2.103    theory value with the theory loader database and updates source version
   2.104    information according to the file store.
   2.105  
     3.1 --- a/src/Doc/Implementation/Isar.thy	Wed Oct 14 15:06:42 2015 +0200
     3.2 +++ b/src/Doc/Implementation/Isar.thy	Wed Oct 14 15:10:32 2015 +0200
     3.3 @@ -81,7 +81,7 @@
     3.4  
     3.5    \begin{description}
     3.6  
     3.7 -  \item Type @{ML_type Proof.state} represents Isar proof states.
     3.8 +  \<^descr> Type @{ML_type Proof.state} represents Isar proof states.
     3.9    This is a block-structured configuration with proof context,
    3.10    linguistic mode, and optional goal.  The latter consists of goal
    3.11    context, goal facts (``@{text "using"}''), and tactical goal state
    3.12 @@ -91,7 +91,7 @@
    3.13    refinement of some parts of the tactical goal --- how exactly is
    3.14    defined by the proof method that is applied in that situation.
    3.15  
    3.16 -  \item @{ML Proof.assert_forward}, @{ML Proof.assert_chain}, @{ML
    3.17 +  \<^descr> @{ML Proof.assert_forward}, @{ML Proof.assert_chain}, @{ML
    3.18    Proof.assert_backward} are partial identity functions that fail
    3.19    unless a certain linguistic mode is active, namely ``@{text
    3.20    "proof(state)"}'', ``@{text "proof(chain)"}'', ``@{text
    3.21 @@ -101,24 +101,24 @@
    3.22    It is advisable study the implementations of existing proof commands
    3.23    for suitable modes to be asserted.
    3.24  
    3.25 -  \item @{ML Proof.simple_goal}~@{text "state"} returns the structured
    3.26 +  \<^descr> @{ML Proof.simple_goal}~@{text "state"} returns the structured
    3.27    Isar goal (if available) in the form seen by ``simple'' methods
    3.28    (like @{method simp} or @{method blast}).  The Isar goal facts are
    3.29    already inserted as premises into the subgoals, which are presented
    3.30    individually as in @{ML Proof.goal}.
    3.31  
    3.32 -  \item @{ML Proof.goal}~@{text "state"} returns the structured Isar
    3.33 +  \<^descr> @{ML Proof.goal}~@{text "state"} returns the structured Isar
    3.34    goal (if available) in the form seen by regular methods (like
    3.35    @{method rule}).  The auxiliary internal encoding of Pure
    3.36    conjunctions is split into individual subgoals as usual.
    3.37  
    3.38 -  \item @{ML Proof.raw_goal}~@{text "state"} returns the structured
    3.39 +  \<^descr> @{ML Proof.raw_goal}~@{text "state"} returns the structured
    3.40    Isar goal (if available) in the raw internal form seen by ``raw''
    3.41    methods (like @{method induct}).  This form is rarely appropriate
    3.42    for diagnostic tools; @{ML Proof.simple_goal} or @{ML Proof.goal}
    3.43    should be used in most situations.
    3.44  
    3.45 -  \item @{ML Proof.theorem}~@{text "before_qed after_qed statement ctxt"}
    3.46 +  \<^descr> @{ML Proof.theorem}~@{text "before_qed after_qed statement ctxt"}
    3.47    initializes a toplevel Isar proof state within a given context.
    3.48  
    3.49    The optional @{text "before_qed"} method is applied at the end of
    3.50 @@ -150,7 +150,7 @@
    3.51  
    3.52    \begin{description}
    3.53  
    3.54 -  \item @{text "@{Isar.goal}"} refers to the regular goal state (if
    3.55 +  \<^descr> @{text "@{Isar.goal}"} refers to the regular goal state (if
    3.56    available) of the current proof state managed by the Isar toplevel
    3.57    --- as abstract value.
    3.58  
    3.59 @@ -320,33 +320,33 @@
    3.60  
    3.61    \begin{description}
    3.62  
    3.63 -  \item Type @{ML_type Proof.method} represents proof methods as
    3.64 +  \<^descr> Type @{ML_type Proof.method} represents proof methods as
    3.65    abstract type.
    3.66  
    3.67 -  \item @{ML METHOD_CASES}~@{text "(fn facts => cases_tactic)"} wraps
    3.68 +  \<^descr> @{ML METHOD_CASES}~@{text "(fn facts => cases_tactic)"} wraps
    3.69    @{text cases_tactic} depending on goal facts as proof method with
    3.70    cases; the goal context is passed via method syntax.
    3.71  
    3.72 -  \item @{ML METHOD}~@{text "(fn facts => tactic)"} wraps @{text
    3.73 +  \<^descr> @{ML METHOD}~@{text "(fn facts => tactic)"} wraps @{text
    3.74    tactic} depending on goal facts as regular proof method; the goal
    3.75    context is passed via method syntax.
    3.76  
    3.77 -  \item @{ML SIMPLE_METHOD}~@{text "tactic"} wraps a tactic that
    3.78 +  \<^descr> @{ML SIMPLE_METHOD}~@{text "tactic"} wraps a tactic that
    3.79    addresses all subgoals uniformly as simple proof method.  Goal facts
    3.80    are already inserted into all subgoals before @{text "tactic"} is
    3.81    applied.
    3.82  
    3.83 -  \item @{ML SIMPLE_METHOD'}~@{text "tactic"} wraps a tactic that
    3.84 +  \<^descr> @{ML SIMPLE_METHOD'}~@{text "tactic"} wraps a tactic that
    3.85    addresses a specific subgoal as simple proof method that operates on
    3.86    subgoal 1.  Goal facts are inserted into the subgoal then the @{text
    3.87    "tactic"} is applied.
    3.88  
    3.89 -  \item @{ML Method.insert_tac}~@{text "facts i"} inserts @{text
    3.90 +  \<^descr> @{ML Method.insert_tac}~@{text "facts i"} inserts @{text
    3.91    "facts"} into subgoal @{text "i"}.  This is convenient to reproduce
    3.92    part of the @{ML SIMPLE_METHOD} or @{ML SIMPLE_METHOD'} wrapping
    3.93    within regular @{ML METHOD}, for example.
    3.94  
    3.95 -  \item @{ML Method.setup}~@{text "name parser description"} provides
    3.96 +  \<^descr> @{ML Method.setup}~@{text "name parser description"} provides
    3.97    the functionality of the Isar command @{command method_setup} as ML
    3.98    function.
    3.99  
   3.100 @@ -548,17 +548,17 @@
   3.101  
   3.102    \begin{description}
   3.103  
   3.104 -  \item Type @{ML_type attribute} represents attributes as concrete
   3.105 +  \<^descr> Type @{ML_type attribute} represents attributes as concrete
   3.106    type alias.
   3.107  
   3.108 -  \item @{ML Thm.rule_attribute}~@{text "(fn context => rule)"} wraps
   3.109 +  \<^descr> @{ML Thm.rule_attribute}~@{text "(fn context => rule)"} wraps
   3.110    a context-dependent rule (mapping on @{ML_type thm}) as attribute.
   3.111  
   3.112 -  \item @{ML Thm.declaration_attribute}~@{text "(fn thm => decl)"}
   3.113 +  \<^descr> @{ML Thm.declaration_attribute}~@{text "(fn thm => decl)"}
   3.114    wraps a theorem-dependent declaration (mapping on @{ML_type
   3.115    Context.generic}) as attribute.
   3.116  
   3.117 -  \item @{ML Attrib.setup}~@{text "name parser description"} provides
   3.118 +  \<^descr> @{ML Attrib.setup}~@{text "name parser description"} provides
   3.119    the functionality of the Isar command @{command attribute_setup} as
   3.120    ML function.
   3.121  
   3.122 @@ -576,7 +576,7 @@
   3.123  
   3.124    \begin{description}
   3.125  
   3.126 -  \item @{text "@{attributes [\<dots>]}"} embeds attribute source
   3.127 +  \<^descr> @{text "@{attributes [\<dots>]}"} embeds attribute source
   3.128    representation into the ML text, which is particularly useful with
   3.129    declarations like @{ML Local_Theory.note}.  Attribute names are
   3.130    internalized at compile time, but the source is unevaluated.  This
     4.1 --- a/src/Doc/Implementation/Local_Theory.thy	Wed Oct 14 15:06:42 2015 +0200
     4.2 +++ b/src/Doc/Implementation/Local_Theory.thy	Wed Oct 14 15:10:32 2015 +0200
     4.3 @@ -105,7 +105,7 @@
     4.4  
     4.5    \begin{description}
     4.6  
     4.7 -  \item Type @{ML_type local_theory} represents local theories.
     4.8 +  \<^descr> Type @{ML_type local_theory} represents local theories.
     4.9    Although this is merely an alias for @{ML_type Proof.context}, it is
    4.10    semantically a subtype of the same: a @{ML_type local_theory} holds
    4.11    target information as special context data.  Subtyping means that
    4.12 @@ -113,7 +113,7 @@
    4.13    with operations on expecting a regular @{text "ctxt:"}~@{ML_type
    4.14    Proof.context}.
    4.15  
    4.16 -  \item @{ML Named_Target.init}~@{text "before_exit name thy"}
    4.17 +  \<^descr> @{ML Named_Target.init}~@{text "before_exit name thy"}
    4.18    initializes a local theory derived from the given background theory.
    4.19    An empty name refers to a \emph{global theory} context, and a
    4.20    non-empty name refers to a @{command locale} or @{command class}
    4.21 @@ -121,7 +121,7 @@
    4.22    useful for experimentation --- normally the Isar toplevel already
    4.23    takes care to initialize the local theory context.
    4.24  
    4.25 -  \item @{ML Local_Theory.define}~@{text "((b, mx), (a, rhs))
    4.26 +  \<^descr> @{ML Local_Theory.define}~@{text "((b, mx), (a, rhs))
    4.27    lthy"} defines a local entity according to the specification that is
    4.28    given relatively to the current @{text "lthy"} context.  In
    4.29    particular the term of the RHS may refer to earlier local entities
    4.30 @@ -141,7 +141,7 @@
    4.31    declarations such as @{attribute simp}, while non-trivial rules like
    4.32    @{attribute simplified} are better avoided.
    4.33  
    4.34 -  \item @{ML Local_Theory.note}~@{text "(a, ths) lthy"} is
    4.35 +  \<^descr> @{ML Local_Theory.note}~@{text "(a, ths) lthy"} is
    4.36    analogous to @{ML Local_Theory.define}, but defines facts instead of
    4.37    terms.  There is also a slightly more general variant @{ML
    4.38    Local_Theory.notes} that defines several facts (with attribute
     5.1 --- a/src/Doc/Implementation/Logic.thy	Wed Oct 14 15:06:42 2015 +0200
     5.2 +++ b/src/Doc/Implementation/Logic.thy	Wed Oct 14 15:10:32 2015 +0200
     5.3 @@ -140,50 +140,50 @@
     5.4  
     5.5    \begin{description}
     5.6  
     5.7 -  \item Type @{ML_type class} represents type classes.
     5.8 +  \<^descr> Type @{ML_type class} represents type classes.
     5.9  
    5.10 -  \item Type @{ML_type sort} represents sorts, i.e.\ finite
    5.11 +  \<^descr> Type @{ML_type sort} represents sorts, i.e.\ finite
    5.12    intersections of classes.  The empty list @{ML "[]: sort"} refers to
    5.13    the empty class intersection, i.e.\ the ``full sort''.
    5.14  
    5.15 -  \item Type @{ML_type arity} represents type arities.  A triple
    5.16 +  \<^descr> Type @{ML_type arity} represents type arities.  A triple
    5.17    @{text "(\<kappa>, \<^vec>s, s) : arity"} represents @{text "\<kappa> ::
    5.18    (\<^vec>s)s"} as described above.
    5.19  
    5.20 -  \item Type @{ML_type typ} represents types; this is a datatype with
    5.21 +  \<^descr> Type @{ML_type typ} represents types; this is a datatype with
    5.22    constructors @{ML TFree}, @{ML TVar}, @{ML Type}.
    5.23  
    5.24 -  \item @{ML Term.map_atyps}~@{text "f \<tau>"} applies the mapping @{text
    5.25 +  \<^descr> @{ML Term.map_atyps}~@{text "f \<tau>"} applies the mapping @{text
    5.26    "f"} to all atomic types (@{ML TFree}, @{ML TVar}) occurring in
    5.27    @{text "\<tau>"}.
    5.28  
    5.29 -  \item @{ML Term.fold_atyps}~@{text "f \<tau>"} iterates the operation
    5.30 +  \<^descr> @{ML Term.fold_atyps}~@{text "f \<tau>"} iterates the operation
    5.31    @{text "f"} over all occurrences of atomic types (@{ML TFree}, @{ML
    5.32    TVar}) in @{text "\<tau>"}; the type structure is traversed from left to
    5.33    right.
    5.34  
    5.35 -  \item @{ML Sign.subsort}~@{text "thy (s\<^sub>1, s\<^sub>2)"}
    5.36 +  \<^descr> @{ML Sign.subsort}~@{text "thy (s\<^sub>1, s\<^sub>2)"}
    5.37    tests the subsort relation @{text "s\<^sub>1 \<subseteq> s\<^sub>2"}.
    5.38  
    5.39 -  \item @{ML Sign.of_sort}~@{text "thy (\<tau>, s)"} tests whether type
    5.40 +  \<^descr> @{ML Sign.of_sort}~@{text "thy (\<tau>, s)"} tests whether type
    5.41    @{text "\<tau>"} is of sort @{text "s"}.
    5.42  
    5.43 -  \item @{ML Sign.add_type}~@{text "ctxt (\<kappa>, k, mx)"} declares a
    5.44 +  \<^descr> @{ML Sign.add_type}~@{text "ctxt (\<kappa>, k, mx)"} declares a
    5.45    new type constructors @{text "\<kappa>"} with @{text "k"} arguments and
    5.46    optional mixfix syntax.
    5.47  
    5.48 -  \item @{ML Sign.add_type_abbrev}~@{text "ctxt (\<kappa>, \<^vec>\<alpha>, \<tau>)"}
    5.49 +  \<^descr> @{ML Sign.add_type_abbrev}~@{text "ctxt (\<kappa>, \<^vec>\<alpha>, \<tau>)"}
    5.50    defines a new type abbreviation @{text "(\<^vec>\<alpha>)\<kappa> = \<tau>"}.
    5.51  
    5.52 -  \item @{ML Sign.primitive_class}~@{text "(c, [c\<^sub>1, \<dots>,
    5.53 +  \<^descr> @{ML Sign.primitive_class}~@{text "(c, [c\<^sub>1, \<dots>,
    5.54    c\<^sub>n])"} declares a new class @{text "c"}, together with class
    5.55    relations @{text "c \<subseteq> c\<^sub>i"}, for @{text "i = 1, \<dots>, n"}.
    5.56  
    5.57 -  \item @{ML Sign.primitive_classrel}~@{text "(c\<^sub>1,
    5.58 +  \<^descr> @{ML Sign.primitive_classrel}~@{text "(c\<^sub>1,
    5.59    c\<^sub>2)"} declares the class relation @{text "c\<^sub>1 \<subseteq>
    5.60    c\<^sub>2"}.
    5.61  
    5.62 -  \item @{ML Sign.primitive_arity}~@{text "(\<kappa>, \<^vec>s, s)"} declares
    5.63 +  \<^descr> @{ML Sign.primitive_arity}~@{text "(\<kappa>, \<^vec>s, s)"} declares
    5.64    the arity @{text "\<kappa> :: (\<^vec>s)s"}.
    5.65  
    5.66    \end{description}
    5.67 @@ -213,23 +213,23 @@
    5.68  
    5.69    \begin{description}
    5.70  
    5.71 -  \item @{text "@{class c}"} inlines the internalized class @{text
    5.72 +  \<^descr> @{text "@{class c}"} inlines the internalized class @{text
    5.73    "c"} --- as @{ML_type string} literal.
    5.74  
    5.75 -  \item @{text "@{sort s}"} inlines the internalized sort @{text "s"}
    5.76 +  \<^descr> @{text "@{sort s}"} inlines the internalized sort @{text "s"}
    5.77    --- as @{ML_type "string list"} literal.
    5.78  
    5.79 -  \item @{text "@{type_name c}"} inlines the internalized type
    5.80 +  \<^descr> @{text "@{type_name c}"} inlines the internalized type
    5.81    constructor @{text "c"} --- as @{ML_type string} literal.
    5.82  
    5.83 -  \item @{text "@{type_abbrev c}"} inlines the internalized type
    5.84 +  \<^descr> @{text "@{type_abbrev c}"} inlines the internalized type
    5.85    abbreviation @{text "c"} --- as @{ML_type string} literal.
    5.86  
    5.87 -  \item @{text "@{nonterminal c}"} inlines the internalized syntactic
    5.88 +  \<^descr> @{text "@{nonterminal c}"} inlines the internalized syntactic
    5.89    type~/ grammar nonterminal @{text "c"} --- as @{ML_type string}
    5.90    literal.
    5.91  
    5.92 -  \item @{text "@{typ \<tau>}"} inlines the internalized type @{text "\<tau>"}
    5.93 +  \<^descr> @{text "@{typ \<tau>}"} inlines the internalized type @{text "\<tau>"}
    5.94    --- as constructor term for datatype @{ML_type typ}.
    5.95  
    5.96    \end{description}
    5.97 @@ -385,58 +385,58 @@
    5.98  
    5.99    \begin{description}
   5.100  
   5.101 -  \item Type @{ML_type term} represents de-Bruijn terms, with comments
   5.102 +  \<^descr> Type @{ML_type term} represents de-Bruijn terms, with comments
   5.103    in abstractions, and explicitly named free variables and constants;
   5.104    this is a datatype with constructors @{index_ML Bound}, @{index_ML
   5.105    Free}, @{index_ML Var}, @{index_ML Const}, @{index_ML Abs},
   5.106    @{index_ML_op "$"}.
   5.107  
   5.108 -  \item @{text "t"}~@{ML_text aconv}~@{text "u"} checks @{text
   5.109 +  \<^descr> @{text "t"}~@{ML_text aconv}~@{text "u"} checks @{text
   5.110    "\<alpha>"}-equivalence of two terms.  This is the basic equality relation
   5.111    on type @{ML_type term}; raw datatype equality should only be used
   5.112    for operations related to parsing or printing!
   5.113  
   5.114 -  \item @{ML Term.map_types}~@{text "f t"} applies the mapping @{text
   5.115 +  \<^descr> @{ML Term.map_types}~@{text "f t"} applies the mapping @{text
   5.116    "f"} to all types occurring in @{text "t"}.
   5.117  
   5.118 -  \item @{ML Term.fold_types}~@{text "f t"} iterates the operation
   5.119 +  \<^descr> @{ML Term.fold_types}~@{text "f t"} iterates the operation
   5.120    @{text "f"} over all occurrences of types in @{text "t"}; the term
   5.121    structure is traversed from left to right.
   5.122  
   5.123 -  \item @{ML Term.map_aterms}~@{text "f t"} applies the mapping @{text
   5.124 +  \<^descr> @{ML Term.map_aterms}~@{text "f t"} applies the mapping @{text
   5.125    "f"} to all atomic terms (@{ML Bound}, @{ML Free}, @{ML Var}, @{ML
   5.126    Const}) occurring in @{text "t"}.
   5.127  
   5.128 -  \item @{ML Term.fold_aterms}~@{text "f t"} iterates the operation
   5.129 +  \<^descr> @{ML Term.fold_aterms}~@{text "f t"} iterates the operation
   5.130    @{text "f"} over all occurrences of atomic terms (@{ML Bound}, @{ML
   5.131    Free}, @{ML Var}, @{ML Const}) in @{text "t"}; the term structure is
   5.132    traversed from left to right.
   5.133  
   5.134 -  \item @{ML fastype_of}~@{text "t"} determines the type of a
   5.135 +  \<^descr> @{ML fastype_of}~@{text "t"} determines the type of a
   5.136    well-typed term.  This operation is relatively slow, despite the
   5.137    omission of any sanity checks.
   5.138  
   5.139 -  \item @{ML lambda}~@{text "a b"} produces an abstraction @{text
   5.140 +  \<^descr> @{ML lambda}~@{text "a b"} produces an abstraction @{text
   5.141    "\<lambda>a. b"}, where occurrences of the atomic term @{text "a"} in the
   5.142    body @{text "b"} are replaced by bound variables.
   5.143  
   5.144 -  \item @{ML betapply}~@{text "(t, u)"} produces an application @{text
   5.145 +  \<^descr> @{ML betapply}~@{text "(t, u)"} produces an application @{text
   5.146    "t u"}, with topmost @{text "\<beta>"}-conversion if @{text "t"} is an
   5.147    abstraction.
   5.148  
   5.149 -  \item @{ML incr_boundvars}~@{text "j"} increments a term's dangling
   5.150 +  \<^descr> @{ML incr_boundvars}~@{text "j"} increments a term's dangling
   5.151    bound variables by the offset @{text "j"}.  This is required when
   5.152    moving a subterm into a context where it is enclosed by a different
   5.153    number of abstractions.  Bound variables with a matching abstraction
   5.154    are unaffected.
   5.155  
   5.156 -  \item @{ML Sign.declare_const}~@{text "ctxt ((c, \<sigma>), mx)"} declares
   5.157 +  \<^descr> @{ML Sign.declare_const}~@{text "ctxt ((c, \<sigma>), mx)"} declares
   5.158    a new constant @{text "c :: \<sigma>"} with optional mixfix syntax.
   5.159  
   5.160 -  \item @{ML Sign.add_abbrev}~@{text "print_mode (c, t)"}
   5.161 +  \<^descr> @{ML Sign.add_abbrev}~@{text "print_mode (c, t)"}
   5.162    introduces a new term abbreviation @{text "c \<equiv> t"}.
   5.163  
   5.164 -  \item @{ML Sign.const_typargs}~@{text "thy (c, \<tau>)"} and @{ML
   5.165 +  \<^descr> @{ML Sign.const_typargs}~@{text "thy (c, \<tau>)"} and @{ML
   5.166    Sign.const_instance}~@{text "thy (c, [\<tau>\<^sub>1, \<dots>, \<tau>\<^sub>n])"}
   5.167    convert between two representations of polymorphic constants: full
   5.168    type instance vs.\ compact type arguments form.
   5.169 @@ -466,22 +466,22 @@
   5.170  
   5.171    \begin{description}
   5.172  
   5.173 -  \item @{text "@{const_name c}"} inlines the internalized logical
   5.174 +  \<^descr> @{text "@{const_name c}"} inlines the internalized logical
   5.175    constant name @{text "c"} --- as @{ML_type string} literal.
   5.176  
   5.177 -  \item @{text "@{const_abbrev c}"} inlines the internalized
   5.178 +  \<^descr> @{text "@{const_abbrev c}"} inlines the internalized
   5.179    abbreviated constant name @{text "c"} --- as @{ML_type string}
   5.180    literal.
   5.181  
   5.182 -  \item @{text "@{const c(\<^vec>\<tau>)}"} inlines the internalized
   5.183 +  \<^descr> @{text "@{const c(\<^vec>\<tau>)}"} inlines the internalized
   5.184    constant @{text "c"} with precise type instantiation in the sense of
   5.185    @{ML Sign.const_instance} --- as @{ML Const} constructor term for
   5.186    datatype @{ML_type term}.
   5.187  
   5.188 -  \item @{text "@{term t}"} inlines the internalized term @{text "t"}
   5.189 +  \<^descr> @{text "@{term t}"} inlines the internalized term @{text "t"}
   5.190    --- as constructor term for datatype @{ML_type term}.
   5.191  
   5.192 -  \item @{text "@{prop \<phi>}"} inlines the internalized proposition
   5.193 +  \<^descr> @{text "@{prop \<phi>}"} inlines the internalized proposition
   5.194    @{text "\<phi>"} --- as constructor term for datatype @{ML_type term}.
   5.195  
   5.196    \end{description}
   5.197 @@ -683,7 +683,7 @@
   5.198  
   5.199    \begin{description}
   5.200  
   5.201 -  \item @{ML Thm.peek_status}~@{text "thm"} informs about the current
   5.202 +  \<^descr> @{ML Thm.peek_status}~@{text "thm"} informs about the current
   5.203    status of the derivation object behind the given theorem.  This is a
   5.204    snapshot of a potentially ongoing (parallel) evaluation of proofs.
   5.205    The three Boolean values indicate the following: @{verbatim oracle}
   5.206 @@ -692,15 +692,15 @@
   5.207    failed} if some future proof has failed, rendering the theorem
   5.208    invalid!
   5.209  
   5.210 -  \item @{ML Logic.all}~@{text "a B"} produces a Pure quantification
   5.211 +  \<^descr> @{ML Logic.all}~@{text "a B"} produces a Pure quantification
   5.212    @{text "\<And>a. B"}, where occurrences of the atomic term @{text "a"} in
   5.213    the body proposition @{text "B"} are replaced by bound variables.
   5.214    (See also @{ML lambda} on terms.)
   5.215  
   5.216 -  \item @{ML Logic.mk_implies}~@{text "(A, B)"} produces a Pure
   5.217 +  \<^descr> @{ML Logic.mk_implies}~@{text "(A, B)"} produces a Pure
   5.218    implication @{text "A \<Longrightarrow> B"}.
   5.219  
   5.220 -  \item Types @{ML_type ctyp} and @{ML_type cterm} represent certified
   5.221 +  \<^descr> Types @{ML_type ctyp} and @{ML_type cterm} represent certified
   5.222    types and terms, respectively.  These are abstract datatypes that
   5.223    guarantee that its values have passed the full well-formedness (and
   5.224    well-typedness) checks, relative to the declarations of type
   5.225 @@ -711,7 +711,7 @@
   5.226    are located in the @{ML_structure Thm} module, even though theorems are
   5.227    not yet involved at that stage.
   5.228  
   5.229 -  \item @{ML Thm.ctyp_of}~@{text "ctxt \<tau>"} and @{ML
   5.230 +  \<^descr> @{ML Thm.ctyp_of}~@{text "ctxt \<tau>"} and @{ML
   5.231    Thm.cterm_of}~@{text "ctxt t"} explicitly check types and terms,
   5.232    respectively.  This also involves some basic normalizations, such
   5.233    expansion of type and term abbreviations from the underlying
   5.234 @@ -719,7 +719,7 @@
   5.235    Full re-certification is relatively slow and should be avoided in
   5.236    tight reasoning loops.
   5.237  
   5.238 -  \item @{ML Thm.apply}, @{ML Thm.lambda}, @{ML Thm.all}, @{ML
   5.239 +  \<^descr> @{ML Thm.apply}, @{ML Thm.lambda}, @{ML Thm.all}, @{ML
   5.240    Drule.mk_implies} etc.\ compose certified terms (or propositions)
   5.241    incrementally.  This is equivalent to @{ML Thm.cterm_of} after
   5.242    unchecked @{ML_op "$"}, @{ML lambda}, @{ML Logic.all}, @{ML
   5.243 @@ -728,53 +728,53 @@
   5.244    constructions on top.  There are separate operations to decompose
   5.245    certified terms and theorems to produce certified terms again.
   5.246  
   5.247 -  \item Type @{ML_type thm} represents proven propositions.  This is
   5.248 +  \<^descr> Type @{ML_type thm} represents proven propositions.  This is
   5.249    an abstract datatype that guarantees that its values have been
   5.250    constructed by basic principles of the @{ML_structure Thm} module.
   5.251    Every @{ML_type thm} value refers its background theory,
   5.252    cf.\ \secref{sec:context-theory}.
   5.253  
   5.254 -  \item @{ML Thm.transfer}~@{text "thy thm"} transfers the given
   5.255 +  \<^descr> @{ML Thm.transfer}~@{text "thy thm"} transfers the given
   5.256    theorem to a \emph{larger} theory, see also \secref{sec:context}.
   5.257    This formal adjustment of the background context has no logical
   5.258    significance, but is occasionally required for formal reasons, e.g.\
   5.259    when theorems that are imported from more basic theories are used in
   5.260    the current situation.
   5.261  
   5.262 -  \item @{ML Thm.assume}, @{ML Thm.forall_intr}, @{ML
   5.263 +  \<^descr> @{ML Thm.assume}, @{ML Thm.forall_intr}, @{ML
   5.264    Thm.forall_elim}, @{ML Thm.implies_intr}, and @{ML Thm.implies_elim}
   5.265    correspond to the primitive inferences of \figref{fig:prim-rules}.
   5.266  
   5.267 -  \item @{ML Thm.generalize}~@{text "(\<^vec>\<alpha>, \<^vec>x)"}
   5.268 +  \<^descr> @{ML Thm.generalize}~@{text "(\<^vec>\<alpha>, \<^vec>x)"}
   5.269    corresponds to the @{text "generalize"} rules of
   5.270    \figref{fig:subst-rules}.  Here collections of type and term
   5.271    variables are generalized simultaneously, specified by the given
   5.272    basic names.
   5.273  
   5.274 -  \item @{ML Thm.instantiate}~@{text "(\<^vec>\<alpha>\<^sub>s,
   5.275 +  \<^descr> @{ML Thm.instantiate}~@{text "(\<^vec>\<alpha>\<^sub>s,
   5.276    \<^vec>x\<^sub>\<tau>)"} corresponds to the @{text "instantiate"} rules
   5.277    of \figref{fig:subst-rules}.  Type variables are substituted before
   5.278    term variables.  Note that the types in @{text "\<^vec>x\<^sub>\<tau>"}
   5.279    refer to the instantiated versions.
   5.280  
   5.281 -  \item @{ML Thm.add_axiom}~@{text "ctxt (name, A)"} declares an
   5.282 +  \<^descr> @{ML Thm.add_axiom}~@{text "ctxt (name, A)"} declares an
   5.283    arbitrary proposition as axiom, and retrieves it as a theorem from
   5.284    the resulting theory, cf.\ @{text "axiom"} in
   5.285    \figref{fig:prim-rules}.  Note that the low-level representation in
   5.286    the axiom table may differ slightly from the returned theorem.
   5.287  
   5.288 -  \item @{ML Thm.add_oracle}~@{text "(binding, oracle)"} produces a named
   5.289 +  \<^descr> @{ML Thm.add_oracle}~@{text "(binding, oracle)"} produces a named
   5.290    oracle rule, essentially generating arbitrary axioms on the fly,
   5.291    cf.\ @{text "axiom"} in \figref{fig:prim-rules}.
   5.292  
   5.293 -  \item @{ML Thm.add_def}~@{text "ctxt unchecked overloaded (name, c
   5.294 +  \<^descr> @{ML Thm.add_def}~@{text "ctxt unchecked overloaded (name, c
   5.295    \<^vec>x \<equiv> t)"} states a definitional axiom for an existing constant
   5.296    @{text "c"}.  Dependencies are recorded via @{ML Theory.add_deps},
   5.297    unless the @{text "unchecked"} option is set.  Note that the
   5.298    low-level representation in the axiom table may differ slightly from
   5.299    the returned theorem.
   5.300  
   5.301 -  \item @{ML Theory.add_deps}~@{text "ctxt name c\<^sub>\<tau> \<^vec>d\<^sub>\<sigma>"}
   5.302 +  \<^descr> @{ML Theory.add_deps}~@{text "ctxt name c\<^sub>\<tau> \<^vec>d\<^sub>\<sigma>"}
   5.303    declares dependencies of a named specification for constant @{text
   5.304    "c\<^sub>\<tau>"}, relative to existing specifications for constants @{text
   5.305    "\<^vec>d\<^sub>\<sigma>"}.  This also works for type constructors.
   5.306 @@ -810,21 +810,21 @@
   5.307  
   5.308    \begin{description}
   5.309  
   5.310 -  \item @{text "@{ctyp \<tau>}"} produces a certified type wrt.\ the
   5.311 +  \<^descr> @{text "@{ctyp \<tau>}"} produces a certified type wrt.\ the
   5.312    current background theory --- as abstract value of type @{ML_type
   5.313    ctyp}.
   5.314  
   5.315 -  \item @{text "@{cterm t}"} and @{text "@{cprop \<phi>}"} produce a
   5.316 +  \<^descr> @{text "@{cterm t}"} and @{text "@{cprop \<phi>}"} produce a
   5.317    certified term wrt.\ the current background theory --- as abstract
   5.318    value of type @{ML_type cterm}.
   5.319  
   5.320 -  \item @{text "@{thm a}"} produces a singleton fact --- as abstract
   5.321 +  \<^descr> @{text "@{thm a}"} produces a singleton fact --- as abstract
   5.322    value of type @{ML_type thm}.
   5.323  
   5.324 -  \item @{text "@{thms a}"} produces a general fact --- as abstract
   5.325 +  \<^descr> @{text "@{thms a}"} produces a general fact --- as abstract
   5.326    value of type @{ML_type "thm list"}.
   5.327  
   5.328 -  \item @{text "@{lemma \<phi> by meth}"} produces a fact that is proven on
   5.329 +  \<^descr> @{text "@{lemma \<phi> by meth}"} produces a fact that is proven on
   5.330    the spot according to the minimal proof, which imitates a terminal
   5.331    Isar proof.  The result is an abstract value of type @{ML_type thm}
   5.332    or @{ML_type "thm list"}, depending on the number of propositions
   5.333 @@ -917,21 +917,21 @@
   5.334  
   5.335    \begin{description}
   5.336  
   5.337 -  \item @{ML Conjunction.intr} derives @{text "A &&& B"} from @{text
   5.338 +  \<^descr> @{ML Conjunction.intr} derives @{text "A &&& B"} from @{text
   5.339    "A"} and @{text "B"}.
   5.340  
   5.341 -  \item @{ML Conjunction.elim} derives @{text "A"} and @{text "B"}
   5.342 +  \<^descr> @{ML Conjunction.elim} derives @{text "A"} and @{text "B"}
   5.343    from @{text "A &&& B"}.
   5.344  
   5.345 -  \item @{ML Drule.mk_term} derives @{text "TERM t"}.
   5.346 +  \<^descr> @{ML Drule.mk_term} derives @{text "TERM t"}.
   5.347  
   5.348 -  \item @{ML Drule.dest_term} recovers term @{text "t"} from @{text
   5.349 +  \<^descr> @{ML Drule.dest_term} recovers term @{text "t"} from @{text
   5.350    "TERM t"}.
   5.351  
   5.352 -  \item @{ML Logic.mk_type}~@{text "\<tau>"} produces the term @{text
   5.353 +  \<^descr> @{ML Logic.mk_type}~@{text "\<tau>"} produces the term @{text
   5.354    "TYPE(\<tau>)"}.
   5.355  
   5.356 -  \item @{ML Logic.dest_type}~@{text "TYPE(\<tau>)"} recovers the type
   5.357 +  \<^descr> @{ML Logic.dest_type}~@{text "TYPE(\<tau>)"} recovers the type
   5.358    @{text "\<tau>"}.
   5.359  
   5.360    \end{description}
   5.361 @@ -974,11 +974,11 @@
   5.362  
   5.363    \begin{description}
   5.364  
   5.365 -  \item @{ML Thm.extra_shyps}~@{text "thm"} determines the extraneous
   5.366 +  \<^descr> @{ML Thm.extra_shyps}~@{text "thm"} determines the extraneous
   5.367    sort hypotheses of the given theorem, i.e.\ the sorts that are not
   5.368    present within type variables of the statement.
   5.369  
   5.370 -  \item @{ML Thm.strip_shyps}~@{text "thm"} removes any extraneous
   5.371 +  \<^descr> @{ML Thm.strip_shyps}~@{text "thm"} removes any extraneous
   5.372    sort hypotheses that can be witnessed from the type signature.
   5.373  
   5.374    \end{description}
   5.375 @@ -1092,7 +1092,7 @@
   5.376  
   5.377    \begin{description}
   5.378  
   5.379 -  \item @{ML Simplifier.norm_hhf}~@{text "ctxt thm"} normalizes the given
   5.380 +  \<^descr> @{ML Simplifier.norm_hhf}~@{text "ctxt thm"} normalizes the given
   5.381    theorem according to the canonical form specified above.  This is
   5.382    occasionally helpful to repair some low-level tools that do not
   5.383    handle Hereditary Harrop Formulae properly.
   5.384 @@ -1176,7 +1176,7 @@
   5.385  
   5.386    \begin{description}
   5.387  
   5.388 -  \item @{text "rule\<^sub>1 RSN (i, rule\<^sub>2)"} resolves the conclusion of
   5.389 +  \<^descr> @{text "rule\<^sub>1 RSN (i, rule\<^sub>2)"} resolves the conclusion of
   5.390    @{text "rule\<^sub>1"} with the @{text i}-th premise of @{text "rule\<^sub>2"},
   5.391    according to the @{inference resolution} principle explained above.
   5.392    Unless there is precisely one resolvent it raises exception @{ML
   5.393 @@ -1185,10 +1185,10 @@
   5.394    This corresponds to the rule attribute @{attribute THEN} in Isar
   5.395    source language.
   5.396  
   5.397 -  \item @{text "rule\<^sub>1 RS rule\<^sub>2"} abbreviates @{text "rule\<^sub>1 RSN (1,
   5.398 +  \<^descr> @{text "rule\<^sub>1 RS rule\<^sub>2"} abbreviates @{text "rule\<^sub>1 RSN (1,
   5.399    rule\<^sub>2)"}.
   5.400  
   5.401 -  \item @{text "rules\<^sub>1 RLN (i, rules\<^sub>2)"} joins lists of rules.  For
   5.402 +  \<^descr> @{text "rules\<^sub>1 RLN (i, rules\<^sub>2)"} joins lists of rules.  For
   5.403    every @{text "rule\<^sub>1"} in @{text "rules\<^sub>1"} and @{text "rule\<^sub>2"} in
   5.404    @{text "rules\<^sub>2"}, it resolves the conclusion of @{text "rule\<^sub>1"} with
   5.405    the @{text "i"}-th premise of @{text "rule\<^sub>2"}, accumulating multiple
   5.406 @@ -1196,15 +1196,15 @@
   5.407    higher-order unifications can be inefficient compared to the lazy
   5.408    variant seen in elementary tactics like @{ML resolve_tac}.
   5.409  
   5.410 -  \item @{text "rules\<^sub>1 RL rules\<^sub>2"} abbreviates @{text "rules\<^sub>1 RLN (1,
   5.411 +  \<^descr> @{text "rules\<^sub>1 RL rules\<^sub>2"} abbreviates @{text "rules\<^sub>1 RLN (1,
   5.412    rules\<^sub>2)"}.
   5.413  
   5.414 -  \item @{text "[rule\<^sub>1, \<dots>, rule\<^sub>n] MRS rule"} resolves @{text "rule\<^sub>i"}
   5.415 +  \<^descr> @{text "[rule\<^sub>1, \<dots>, rule\<^sub>n] MRS rule"} resolves @{text "rule\<^sub>i"}
   5.416    against premise @{text "i"} of @{text "rule"}, for @{text "i = n, \<dots>,
   5.417    1"}.  By working from right to left, newly emerging premises are
   5.418    concatenated in the result, without interfering.
   5.419  
   5.420 -  \item @{text "rule OF rules"} is an alternative notation for @{text
   5.421 +  \<^descr> @{text "rule OF rules"} is an alternative notation for @{text
   5.422    "rules MRS rule"}, which makes rule composition look more like
   5.423    function application.  Note that the argument @{text "rules"} need
   5.424    not be atomic.
   5.425 @@ -1361,21 +1361,21 @@
   5.426  
   5.427    \begin{description}
   5.428  
   5.429 -  \item Type @{ML_type proof} represents proof terms; this is a
   5.430 +  \<^descr> Type @{ML_type proof} represents proof terms; this is a
   5.431    datatype with constructors @{index_ML Abst}, @{index_ML AbsP},
   5.432    @{index_ML_op "%"}, @{index_ML_op "%%"}, @{index_ML PBound},
   5.433    @{index_ML MinProof}, @{index_ML Hyp}, @{index_ML PAxm}, @{index_ML
   5.434    Oracle}, @{index_ML Promise}, @{index_ML PThm} as explained above.
   5.435    %FIXME OfClass (!?)
   5.436  
   5.437 -  \item Type @{ML_type proof_body} represents the nested proof
   5.438 +  \<^descr> Type @{ML_type proof_body} represents the nested proof
   5.439    information of a named theorem, consisting of a digest of oracles
   5.440    and named theorem over some proof term.  The digest only covers the
   5.441    directly visible part of the proof: in order to get the full
   5.442    information, the implicit graph of nested theorems needs to be
   5.443    traversed (e.g.\ using @{ML Proofterm.fold_body_thms}).
   5.444  
   5.445 -  \item @{ML Thm.proof_of}~@{text "thm"} and @{ML
   5.446 +  \<^descr> @{ML Thm.proof_of}~@{text "thm"} and @{ML
   5.447    Thm.proof_body_of}~@{text "thm"} produce the proof term or proof
   5.448    body (with digest of oracles and theorems) from a given theorem.
   5.449    Note that this involves a full join of internal futures that fulfill
   5.450 @@ -1384,14 +1384,14 @@
   5.451    Parallel performance may suffer by inspecting proof terms at
   5.452    run-time.
   5.453  
   5.454 -  \item @{ML proofs} specifies the detail of proof recording within
   5.455 +  \<^descr> @{ML proofs} specifies the detail of proof recording within
   5.456    @{ML_type thm} values produced by the inference kernel: @{ML 0}
   5.457    records only the names of oracles, @{ML 1} records oracle names and
   5.458    propositions, @{ML 2} additionally records full proof terms.
   5.459    Officially named theorems that contribute to a result are recorded
   5.460    in any case.
   5.461  
   5.462 -  \item @{ML Reconstruct.reconstruct_proof}~@{text "thy prop prf"}
   5.463 +  \<^descr> @{ML Reconstruct.reconstruct_proof}~@{text "thy prop prf"}
   5.464    turns the implicit proof term @{text "prf"} into a full proof of the
   5.465    given proposition.
   5.466  
   5.467 @@ -1401,21 +1401,21 @@
   5.468    constructed manually, but not for those produced automatically by
   5.469    the inference kernel.
   5.470  
   5.471 -  \item @{ML Reconstruct.expand_proof}~@{text "thy [thm\<^sub>1, \<dots>, thm\<^sub>n]
   5.472 +  \<^descr> @{ML Reconstruct.expand_proof}~@{text "thy [thm\<^sub>1, \<dots>, thm\<^sub>n]
   5.473    prf"} expands and reconstructs the proofs of all specified theorems,
   5.474    with the given (full) proof.  Theorems that are not unique specified
   5.475    via their name may be disambiguated by giving their proposition.
   5.476  
   5.477 -  \item @{ML Proof_Checker.thm_of_proof}~@{text "thy prf"} turns the
   5.478 +  \<^descr> @{ML Proof_Checker.thm_of_proof}~@{text "thy prf"} turns the
   5.479    given (full) proof into a theorem, by replaying it using only
   5.480    primitive rules of the inference kernel.
   5.481  
   5.482 -  \item @{ML Proof_Syntax.read_proof}~@{text "thy b\<^sub>1 b\<^sub>2 s"} reads in a
   5.483 +  \<^descr> @{ML Proof_Syntax.read_proof}~@{text "thy b\<^sub>1 b\<^sub>2 s"} reads in a
   5.484    proof term. The Boolean flags indicate the use of sort and type
   5.485    information.  Usually, typing information is left implicit and is
   5.486    inferred during proof reconstruction.  %FIXME eliminate flags!?
   5.487  
   5.488 -  \item @{ML Proof_Syntax.pretty_proof}~@{text "ctxt prf"}
   5.489 +  \<^descr> @{ML Proof_Syntax.pretty_proof}~@{text "ctxt prf"}
   5.490    pretty-prints the given proof term.
   5.491  
   5.492    \end{description}
     6.1 --- a/src/Doc/Implementation/ML.thy	Wed Oct 14 15:06:42 2015 +0200
     6.2 +++ b/src/Doc/Implementation/ML.thy	Wed Oct 14 15:10:32 2015 +0200
     6.3 @@ -260,7 +260,7 @@
     6.4    @{ML_text lhs} (not @{ML_text lhs_tm}).  Or a term that is known
     6.5    to be a variable can be called @{ML_text v} or @{ML_text x}.
     6.6  
     6.7 -  \item Tactics (\secref{sec:tactics}) are sufficiently important to
     6.8 +  \<^item> Tactics (\secref{sec:tactics}) are sufficiently important to
     6.9    have specific naming conventions.  The name of a basic tactic
    6.10    definition always has a @{ML_text "_tac"} suffix, the subgoal index
    6.11    (if applicable) is always called @{ML_text i}, and the goal state
    6.12 @@ -648,20 +648,20 @@
    6.13  
    6.14    \begin{description}
    6.15  
    6.16 -  \item @{ML "ML_Context.the_generic_context ()"} refers to the theory
    6.17 +  \<^descr> @{ML "ML_Context.the_generic_context ()"} refers to the theory
    6.18    context of the ML toplevel --- at compile time.  ML code needs to
    6.19    take care to refer to @{ML "ML_Context.the_generic_context ()"}
    6.20    correctly.  Recall that evaluation of a function body is delayed
    6.21    until actual run-time.
    6.22  
    6.23 -  \item @{ML "Context.>>"}~@{text f} applies context transformation
    6.24 +  \<^descr> @{ML "Context.>>"}~@{text f} applies context transformation
    6.25    @{text f} to the implicit context of the ML toplevel.
    6.26  
    6.27 -  \item @{ML ML_Thms.bind_thms}~@{text "(name, thms)"} stores a list of
    6.28 +  \<^descr> @{ML ML_Thms.bind_thms}~@{text "(name, thms)"} stores a list of
    6.29    theorems produced in ML both in the (global) theory context and the
    6.30    ML toplevel, associating it with the provided name.
    6.31  
    6.32 -  \item @{ML ML_Thms.bind_thm} is similar to @{ML ML_Thms.bind_thms} but
    6.33 +  \<^descr> @{ML ML_Thms.bind_thm} is similar to @{ML ML_Thms.bind_thms} but
    6.34    refers to a singleton fact.
    6.35  
    6.36    \end{description}
    6.37 @@ -727,12 +727,12 @@
    6.38  
    6.39    \begin{description}
    6.40  
    6.41 -  \item @{text "@{make_string}"} inlines a function to print arbitrary values
    6.42 +  \<^descr> @{text "@{make_string}"} inlines a function to print arbitrary values
    6.43    similar to the ML toplevel. The result is compiler dependent and may fall
    6.44    back on "?" in certain situations. The value of configuration option
    6.45    @{attribute_ref ML_print_depth} determines further details of output.
    6.46  
    6.47 -  \item @{text "@{print f}"} uses the ML function @{text "f: string ->
    6.48 +  \<^descr> @{text "@{print f}"} uses the ML function @{text "f: string ->
    6.49    unit"} to output the result of @{text "@{make_string}"} above,
    6.50    together with the source position of the antiquotation.  The default
    6.51    output function is @{ML writeln}.
    6.52 @@ -909,13 +909,13 @@
    6.53  
    6.54    \begin{description}
    6.55  
    6.56 -  \item @{ML fold}~@{text f} lifts the parametrized update function
    6.57 +  \<^descr> @{ML fold}~@{text f} lifts the parametrized update function
    6.58    @{text "f"} to a list of parameters.
    6.59  
    6.60 -  \item @{ML fold_rev}~@{text "f"} is similar to @{ML fold}~@{text
    6.61 +  \<^descr> @{ML fold_rev}~@{text "f"} is similar to @{ML fold}~@{text
    6.62    "f"}, but works inside-out, as if the list would be reversed.
    6.63  
    6.64 -  \item @{ML fold_map}~@{text "f"} lifts the parametrized update
    6.65 +  \<^descr> @{ML fold_map}~@{text "f"} lifts the parametrized update
    6.66    function @{text "f"} (with side-result) to a list of parameters and
    6.67    cumulative side-results.
    6.68  
    6.69 @@ -1035,11 +1035,11 @@
    6.70  
    6.71    \begin{description}
    6.72  
    6.73 -  \item @{ML writeln}~@{text "text"} outputs @{text "text"} as regular
    6.74 +  \<^descr> @{ML writeln}~@{text "text"} outputs @{text "text"} as regular
    6.75    message.  This is the primary message output operation of Isabelle
    6.76    and should be used by default.
    6.77  
    6.78 -  \item @{ML tracing}~@{text "text"} outputs @{text "text"} as special
    6.79 +  \<^descr> @{ML tracing}~@{text "text"} outputs @{text "text"} as special
    6.80    tracing message, indicating potential high-volume output to the
    6.81    front-end (hundreds or thousands of messages issued by a single
    6.82    command).  The idea is to allow the user-interface to downgrade the
    6.83 @@ -1049,11 +1049,11 @@
    6.84    output, e.g.\ switch to a different output window.  So this channel
    6.85    should not be used for regular output.
    6.86  
    6.87 -  \item @{ML warning}~@{text "text"} outputs @{text "text"} as
    6.88 +  \<^descr> @{ML warning}~@{text "text"} outputs @{text "text"} as
    6.89    warning, which typically means some extra emphasis on the front-end
    6.90    side (color highlighting, icons, etc.).
    6.91  
    6.92 -  \item @{ML error}~@{text "text"} raises exception @{ML ERROR}~@{text
    6.93 +  \<^descr> @{ML error}~@{text "text"} raises exception @{ML ERROR}~@{text
    6.94    "text"} and thus lets the Isar toplevel print @{text "text"} on the
    6.95    error channel, which typically means some extra emphasis on the
    6.96    front-end side (color highlighting, icons, etc.).
    6.97 @@ -1217,30 +1217,30 @@
    6.98  
    6.99    \begin{description}
   6.100  
   6.101 -  \item @{ML try}~@{text "f x"} makes the partiality of evaluating
   6.102 +  \<^descr> @{ML try}~@{text "f x"} makes the partiality of evaluating
   6.103    @{text "f x"} explicit via the option datatype.  Interrupts are
   6.104    \emph{not} handled here, i.e.\ this form serves as safe replacement
   6.105    for the \emph{unsafe} version @{ML_text "(SOME"}~@{text "f
   6.106    x"}~@{ML_text "handle _ => NONE)"} that is occasionally seen in
   6.107    books about SML97, but not in Isabelle/ML.
   6.108  
   6.109 -  \item @{ML can} is similar to @{ML try} with more abstract result.
   6.110 -
   6.111 -  \item @{ML ERROR}~@{text "msg"} represents user errors; this
   6.112 +  \<^descr> @{ML can} is similar to @{ML try} with more abstract result.
   6.113 +
   6.114 +  \<^descr> @{ML ERROR}~@{text "msg"} represents user errors; this
   6.115    exception is normally raised indirectly via the @{ML error} function
   6.116    (see \secref{sec:message-channels}).
   6.117  
   6.118 -  \item @{ML Fail}~@{text "msg"} represents general program failures.
   6.119 -
   6.120 -  \item @{ML Exn.is_interrupt} identifies interrupts robustly, without
   6.121 +  \<^descr> @{ML Fail}~@{text "msg"} represents general program failures.
   6.122 +
   6.123 +  \<^descr> @{ML Exn.is_interrupt} identifies interrupts robustly, without
   6.124    mentioning concrete exception constructors in user code.  Handled
   6.125    interrupts need to be re-raised promptly!
   6.126  
   6.127 -  \item @{ML reraise}~@{text "exn"} raises exception @{text "exn"}
   6.128 +  \<^descr> @{ML reraise}~@{text "exn"} raises exception @{text "exn"}
   6.129    while preserving its implicit position information (if possible,
   6.130    depending on the ML platform).
   6.131  
   6.132 -  \item @{ML Runtime.exn_trace}~@{ML_text "(fn () =>"}~@{text
   6.133 +  \<^descr> @{ML Runtime.exn_trace}~@{ML_text "(fn () =>"}~@{text
   6.134    "e"}@{ML_text ")"} evaluates expression @{text "e"} while printing
   6.135    a full trace of its stack of nested exceptions (if possible,
   6.136    depending on the ML platform).
   6.137 @@ -1258,7 +1258,7 @@
   6.138  
   6.139    \begin{description}
   6.140  
   6.141 -  \item @{text "@{assert}"} inlines a function
   6.142 +  \<^descr> @{text "@{assert}"} inlines a function
   6.143    @{ML_type "bool -> unit"} that raises @{ML Fail} if the argument is
   6.144    @{ML false}.  Due to inlining the source position of failed
   6.145    assertions is included in the error output.
   6.146 @@ -1339,28 +1339,28 @@
   6.147  
   6.148    \begin{description}
   6.149  
   6.150 -  \item Type @{ML_type "Symbol.symbol"} represents individual Isabelle
   6.151 +  \<^descr> Type @{ML_type "Symbol.symbol"} represents individual Isabelle
   6.152    symbols.
   6.153  
   6.154 -  \item @{ML "Symbol.explode"}~@{text "str"} produces a symbol list
   6.155 +  \<^descr> @{ML "Symbol.explode"}~@{text "str"} produces a symbol list
   6.156    from the packed form.  This function supersedes @{ML
   6.157    "String.explode"} for virtually all purposes of manipulating text in
   6.158    Isabelle!\footnote{The runtime overhead for exploded strings is
   6.159    mainly that of the list structure: individual symbols that happen to
   6.160    be a singleton string do not require extra memory in Poly/ML.}
   6.161  
   6.162 -  \item @{ML "Symbol.is_letter"}, @{ML "Symbol.is_digit"}, @{ML
   6.163 +  \<^descr> @{ML "Symbol.is_letter"}, @{ML "Symbol.is_digit"}, @{ML
   6.164    "Symbol.is_quasi"}, @{ML "Symbol.is_blank"} classify standard
   6.165    symbols according to fixed syntactic conventions of Isabelle, cf.\
   6.166    @{cite "isabelle-isar-ref"}.
   6.167  
   6.168 -  \item Type @{ML_type "Symbol.sym"} is a concrete datatype that
   6.169 +  \<^descr> Type @{ML_type "Symbol.sym"} is a concrete datatype that
   6.170    represents the different kinds of symbols explicitly, with
   6.171    constructors @{ML "Symbol.Char"}, @{ML "Symbol.UTF8"},
   6.172    @{ML "Symbol.Sym"}, @{ML "Symbol.Ctrl"}, @{ML "Symbol.Raw"},
   6.173    @{ML "Symbol.Malformed"}.
   6.174  
   6.175 -  \item @{ML "Symbol.decode"} converts the string representation of a
   6.176 +  \<^descr> @{ML "Symbol.decode"} converts the string representation of a
   6.177    symbol into the datatype version.
   6.178  
   6.179    \end{description}
   6.180 @@ -1401,7 +1401,7 @@
   6.181  
   6.182    \begin{description}
   6.183  
   6.184 -  \item Type @{ML_type char} is \emph{not} used.  The smallest textual
   6.185 +  \<^descr> Type @{ML_type char} is \emph{not} used.  The smallest textual
   6.186    unit in Isabelle is represented as a ``symbol'' (see
   6.187    \secref{sec:symbols}).
   6.188  
   6.189 @@ -1418,7 +1418,7 @@
   6.190  
   6.191    \begin{description}
   6.192  
   6.193 -  \item Type @{ML_type string} represents immutable vectors of 8-bit
   6.194 +  \<^descr> Type @{ML_type string} represents immutable vectors of 8-bit
   6.195    characters.  There are operations in SML to convert back and forth
   6.196    to actual byte vectors, which are seldom used.
   6.197  
   6.198 @@ -1473,7 +1473,7 @@
   6.199  
   6.200    \begin{description}
   6.201  
   6.202 -  \item Type @{ML_type int} represents regular mathematical integers, which
   6.203 +  \<^descr> Type @{ML_type int} represents regular mathematical integers, which
   6.204    are \emph{unbounded}. Overflow is treated properly, but should never happen
   6.205    in practice.\footnote{The size limit for integer bit patterns in memory is
   6.206    64\,MB for 32-bit Poly/ML, and much higher for 64-bit systems.} This works
   6.207 @@ -1501,11 +1501,11 @@
   6.208  
   6.209    \begin{description}
   6.210  
   6.211 -  \item Type @{ML_type Time.time} represents time abstractly according
   6.212 +  \<^descr> Type @{ML_type Time.time} represents time abstractly according
   6.213    to the SML97 basis library definition.  This is adequate for
   6.214    internal ML operations, but awkward in concrete time specifications.
   6.215  
   6.216 -  \item @{ML seconds}~@{text "s"} turns the concrete scalar @{text
   6.217 +  \<^descr> @{ML seconds}~@{text "s"} turns the concrete scalar @{text
   6.218    "s"} (measured in seconds) into an abstract time value.  Floating
   6.219    point numbers are easy to use as configuration options in the
   6.220    context (see \secref{sec:config-options}) or system options that
   6.221 @@ -1553,13 +1553,13 @@
   6.222  
   6.223    \begin{description}
   6.224  
   6.225 -  \item @{ML cons}~@{text "x xs"} evaluates to @{text "x :: xs"}.
   6.226 +  \<^descr> @{ML cons}~@{text "x xs"} evaluates to @{text "x :: xs"}.
   6.227  
   6.228    Tupled infix operators are a historical accident in Standard ML.
   6.229    The curried @{ML cons} amends this, but it should be only used when
   6.230    partial application is required.
   6.231  
   6.232 -  \item @{ML member}, @{ML insert}, @{ML remove}, @{ML update} treat
   6.233 +  \<^descr> @{ML member}, @{ML insert}, @{ML remove}, @{ML update} treat
   6.234    lists as a set-like container that maintains the order of elements.
   6.235    See @{file "~~/src/Pure/library.ML"} for the full specifications
   6.236    (written in ML).  There are some further derived operations like
   6.237 @@ -1629,7 +1629,7 @@
   6.238  
   6.239    \begin{description}
   6.240  
   6.241 -  \item @{ML AList.lookup}, @{ML AList.defined}, @{ML AList.update}
   6.242 +  \<^descr> @{ML AList.lookup}, @{ML AList.defined}, @{ML AList.update}
   6.243    implement the main ``framework operations'' for mappings in
   6.244    Isabelle/ML, following standard conventions for their names and
   6.245    types.
   6.246 @@ -1836,11 +1836,11 @@
   6.247  
   6.248    \begin{description}
   6.249  
   6.250 -  \item @{ML File.tmp_path}~@{text "path"} relocates the base
   6.251 +  \<^descr> @{ML File.tmp_path}~@{text "path"} relocates the base
   6.252    component of @{text "path"} into the unique temporary directory of
   6.253    the running Isabelle/ML process.
   6.254  
   6.255 -  \item @{ML serial_string}~@{text "()"} creates a new serial number
   6.256 +  \<^descr> @{ML serial_string}~@{text "()"} creates a new serial number
   6.257    that is unique over the runtime of the Isabelle/ML process.
   6.258  
   6.259    \end{description}
   6.260 @@ -1883,14 +1883,14 @@
   6.261  
   6.262    \begin{description}
   6.263  
   6.264 -  \item Type @{ML_type "'a Synchronized.var"} represents synchronized
   6.265 +  \<^descr> Type @{ML_type "'a Synchronized.var"} represents synchronized
   6.266    variables with state of type @{ML_type 'a}.
   6.267  
   6.268 -  \item @{ML Synchronized.var}~@{text "name x"} creates a synchronized
   6.269 +  \<^descr> @{ML Synchronized.var}~@{text "name x"} creates a synchronized
   6.270    variable that is initialized with value @{text "x"}.  The @{text
   6.271    "name"} is used for tracing.
   6.272  
   6.273 -  \item @{ML Synchronized.guarded_access}~@{text "var f"} lets the
   6.274 +  \<^descr> @{ML Synchronized.guarded_access}~@{text "var f"} lets the
   6.275    function @{text "f"} operate within a critical section on the state
   6.276    @{text "x"} as follows: if @{text "f x"} produces @{ML NONE}, it
   6.277    continues to wait on the internal condition variable, expecting that
   6.278 @@ -1996,32 +1996,32 @@
   6.279  
   6.280    \begin{description}
   6.281  
   6.282 -  \item Type @{ML_type "'a Exn.result"} represents the disjoint sum of
   6.283 +  \<^descr> Type @{ML_type "'a Exn.result"} represents the disjoint sum of
   6.284    ML results explicitly, with constructor @{ML Exn.Res} for regular
   6.285    values and @{ML "Exn.Exn"} for exceptions.
   6.286  
   6.287 -  \item @{ML Exn.capture}~@{text "f x"} manages the evaluation of
   6.288 +  \<^descr> @{ML Exn.capture}~@{text "f x"} manages the evaluation of
   6.289    @{text "f x"} such that exceptions are made explicit as @{ML
   6.290    "Exn.Exn"}.  Note that this includes physical interrupts (see also
   6.291    \secref{sec:exceptions}), so the same precautions apply to user
   6.292    code: interrupts must not be absorbed accidentally!
   6.293  
   6.294 -  \item @{ML Exn.interruptible_capture} is similar to @{ML
   6.295 +  \<^descr> @{ML Exn.interruptible_capture} is similar to @{ML
   6.296    Exn.capture}, but interrupts are immediately re-raised as required
   6.297    for user code.
   6.298  
   6.299 -  \item @{ML Exn.release}~@{text "result"} releases the original
   6.300 +  \<^descr> @{ML Exn.release}~@{text "result"} releases the original
   6.301    runtime result, exposing its regular value or raising the reified
   6.302    exception.
   6.303  
   6.304 -  \item @{ML Par_Exn.release_all}~@{text "results"} combines results
   6.305 +  \<^descr> @{ML Par_Exn.release_all}~@{text "results"} combines results
   6.306    that were produced independently (e.g.\ by parallel evaluation).  If
   6.307    all results are regular values, that list is returned.  Otherwise,
   6.308    the collection of all exceptions is raised, wrapped-up as collective
   6.309    parallel exception.  Note that the latter prevents access to
   6.310    individual exceptions by conventional @{verbatim "handle"} of ML.
   6.311  
   6.312 -  \item @{ML Par_Exn.release_first} is similar to @{ML
   6.313 +  \<^descr> @{ML Par_Exn.release_first} is similar to @{ML
   6.314    Par_Exn.release_all}, but only the first (meaningful) exception that has
   6.315    occurred in the original evaluation process is raised again, the others are
   6.316    ignored.  That single exception may get handled by conventional
   6.317 @@ -2057,7 +2057,7 @@
   6.318  
   6.319    \begin{description}
   6.320  
   6.321 -  \item @{ML Par_List.map}~@{text "f [x\<^sub>1, \<dots>, x\<^sub>n]"} is like @{ML
   6.322 +  \<^descr> @{ML Par_List.map}~@{text "f [x\<^sub>1, \<dots>, x\<^sub>n]"} is like @{ML
   6.323    "map"}~@{text "f [x\<^sub>1, \<dots>, x\<^sub>n]"}, but the evaluation of @{text "f x\<^sub>i"}
   6.324    for @{text "i = 1, \<dots>, n"} is performed in parallel.
   6.325  
   6.326 @@ -2067,7 +2067,7 @@
   6.327    program exception that happened to occur in the parallel evaluation
   6.328    is propagated, and all other failures are ignored.
   6.329  
   6.330 -  \item @{ML Par_List.get_some}~@{text "f [x\<^sub>1, \<dots>, x\<^sub>n]"} produces some
   6.331 +  \<^descr> @{ML Par_List.get_some}~@{text "f [x\<^sub>1, \<dots>, x\<^sub>n]"} produces some
   6.332    @{text "f x\<^sub>i"} that is of the form @{text "SOME y\<^sub>i"}, if that
   6.333    exists, otherwise @{text "NONE"}.  Thus it is similar to @{ML
   6.334    Library.get_first}, but subject to a non-deterministic parallel
   6.335 @@ -2130,19 +2130,19 @@
   6.336  
   6.337    \begin{description}
   6.338  
   6.339 -  \item Type @{ML_type "'a lazy"} represents lazy values over type @{verbatim
   6.340 +  \<^descr> Type @{ML_type "'a lazy"} represents lazy values over type @{verbatim
   6.341    "'a"}.
   6.342  
   6.343 -  \item @{ML Lazy.lazy}~@{text "(fn () => e)"} wraps the unevaluated
   6.344 +  \<^descr> @{ML Lazy.lazy}~@{text "(fn () => e)"} wraps the unevaluated
   6.345    expression @{text e} as unfinished lazy value.
   6.346  
   6.347 -  \item @{ML Lazy.value}~@{text a} wraps the value @{text a} as finished lazy
   6.348 +  \<^descr> @{ML Lazy.value}~@{text a} wraps the value @{text a} as finished lazy
   6.349    value.  When forced, it returns @{text a} without any further evaluation.
   6.350  
   6.351    There is very low overhead for this proforma wrapping of strict values as
   6.352    lazy values.
   6.353  
   6.354 -  \item @{ML Lazy.force}~@{text x} produces the result of the lazy value in a
   6.355 +  \<^descr> @{ML Lazy.force}~@{text x} produces the result of the lazy value in a
   6.356    thread-safe manner as explained above. Thus it may cause the current thread
   6.357    to wait on a pending evaluation attempt by another thread.
   6.358  
   6.359 @@ -2223,15 +2223,15 @@
   6.360  
   6.361    \begin{description}
   6.362  
   6.363 -  \item Type @{ML_type "'a future"} represents future values over type
   6.364 +  \<^descr> Type @{ML_type "'a future"} represents future values over type
   6.365    @{verbatim "'a"}.
   6.366  
   6.367 -  \item @{ML Future.fork}~@{text "(fn () => e)"} registers the unevaluated
   6.368 +  \<^descr> @{ML Future.fork}~@{text "(fn () => e)"} registers the unevaluated
   6.369    expression @{text e} as unfinished future value, to be evaluated eventually
   6.370    on the parallel worker-thread farm. This is a shorthand for @{ML
   6.371    Future.forks} below, with default parameters and a single expression.
   6.372  
   6.373 -  \item @{ML Future.forks}~@{text "params exprs"} is the general interface to
   6.374 +  \<^descr> @{ML Future.forks}~@{text "params exprs"} is the general interface to
   6.375    fork several futures simultaneously. The @{text params} consist of the
   6.376    following fields:
   6.377  
   6.378 @@ -2273,7 +2273,7 @@
   6.379  
   6.380    \end{itemize}
   6.381  
   6.382 -  \item @{ML Future.join}~@{text x} retrieves the value of an already finished
   6.383 +  \<^descr> @{ML Future.join}~@{text x} retrieves the value of an already finished
   6.384    future, which may lead to an exception, according to the result of its
   6.385    previous evaluation.
   6.386  
   6.387 @@ -2295,7 +2295,7 @@
   6.388    explicitly when forked (see @{text deps} above). Thus the evaluation can
   6.389    work from the bottom up, without join conflicts and wait states.
   6.390  
   6.391 -  \item @{ML Future.joins}~@{text xs} joins the given list of futures
   6.392 +  \<^descr> @{ML Future.joins}~@{text xs} joins the given list of futures
   6.393    simultaneously, which is more efficient than @{ML "map Future.join"}~@{text
   6.394    xs}.
   6.395  
   6.396 @@ -2305,23 +2305,23 @@
   6.397    presently evaluated on other threads only happens as last resort, when no
   6.398    other unfinished futures are left over.
   6.399  
   6.400 -  \item @{ML Future.value}~@{text a} wraps the value @{text a} as finished
   6.401 +  \<^descr> @{ML Future.value}~@{text a} wraps the value @{text a} as finished
   6.402    future value, bypassing the worker-thread farm. When joined, it returns
   6.403    @{text a} without any further evaluation.
   6.404  
   6.405    There is very low overhead for this proforma wrapping of strict values as
   6.406    futures.
   6.407  
   6.408 -  \item @{ML Future.map}~@{text "f x"} is a fast-path implementation of @{ML
   6.409 +  \<^descr> @{ML Future.map}~@{text "f x"} is a fast-path implementation of @{ML
   6.410    Future.fork}~@{text "(fn () => f ("}@{ML Future.join}~@{text "x))"}, which
   6.411    avoids the full overhead of the task queue and worker-thread farm as far as
   6.412    possible. The function @{text f} is supposed to be some trivial
   6.413    post-processing or projection of the future result.
   6.414  
   6.415 -  \item @{ML Future.cancel}~@{text "x"} cancels the task group of the given
   6.416 +  \<^descr> @{ML Future.cancel}~@{text "x"} cancels the task group of the given
   6.417    future, using @{ML Future.cancel_group} below.
   6.418  
   6.419 -  \item @{ML Future.cancel_group}~@{text "group"} cancels all tasks of the
   6.420 +  \<^descr> @{ML Future.cancel_group}~@{text "group"} cancels all tasks of the
   6.421    given task group for all time. Threads that are presently processing a task
   6.422    of the given group are interrupted: it may take some time until they are
   6.423    actually terminated. Tasks that are queued but not yet processed are
   6.424 @@ -2329,11 +2329,11 @@
   6.425    invalidated, any further attempt to fork a future that belongs to it will
   6.426    yield a canceled result as well.
   6.427  
   6.428 -  \item @{ML Future.promise}~@{text abort} registers a passive future with the
   6.429 +  \<^descr> @{ML Future.promise}~@{text abort} registers a passive future with the
   6.430    given @{text abort} operation: it is invoked when the future task group is
   6.431    canceled.
   6.432  
   6.433 -  \item @{ML Future.fulfill}~@{text "x a"} finishes the passive future @{text
   6.434 +  \<^descr> @{ML Future.fulfill}~@{text "x a"} finishes the passive future @{text
   6.435    x} by the given value @{text a}. If the promise has already been canceled,
   6.436    the attempt to fulfill it causes an exception.
   6.437  
     7.1 --- a/src/Doc/Implementation/Prelim.thy	Wed Oct 14 15:06:42 2015 +0200
     7.2 +++ b/src/Doc/Implementation/Prelim.thy	Wed Oct 14 15:10:32 2015 +0200
     7.3 @@ -131,25 +131,25 @@
     7.4  
     7.5    \begin{description}
     7.6  
     7.7 -  \item Type @{ML_type theory} represents theory contexts.
     7.8 +  \<^descr> Type @{ML_type theory} represents theory contexts.
     7.9  
    7.10 -  \item @{ML "Context.eq_thy"}~@{text "(thy\<^sub>1, thy\<^sub>2)"} check strict
    7.11 +  \<^descr> @{ML "Context.eq_thy"}~@{text "(thy\<^sub>1, thy\<^sub>2)"} check strict
    7.12    identity of two theories.
    7.13  
    7.14 -  \item @{ML "Context.subthy"}~@{text "(thy\<^sub>1, thy\<^sub>2)"} compares theories
    7.15 +  \<^descr> @{ML "Context.subthy"}~@{text "(thy\<^sub>1, thy\<^sub>2)"} compares theories
    7.16    according to the intrinsic graph structure of the construction.
    7.17    This sub-theory relation is a nominal approximation of inclusion
    7.18    (@{text "\<subseteq>"}) of the corresponding content (according to the
    7.19    semantics of the ML modules that implement the data).
    7.20  
    7.21 -  \item @{ML "Theory.begin_theory"}~@{text "name parents"} constructs
    7.22 +  \<^descr> @{ML "Theory.begin_theory"}~@{text "name parents"} constructs
    7.23    a new theory based on the given parents.  This ML function is
    7.24    normally not invoked directly.
    7.25  
    7.26 -  \item @{ML "Theory.parents_of"}~@{text "thy"} returns the direct
    7.27 +  \<^descr> @{ML "Theory.parents_of"}~@{text "thy"} returns the direct
    7.28    ancestors of @{text thy}.
    7.29  
    7.30 -  \item @{ML "Theory.ancestors_of"}~@{text "thy"} returns all
    7.31 +  \<^descr> @{ML "Theory.ancestors_of"}~@{text "thy"} returns all
    7.32    ancestors of @{text thy} (not including @{text thy} itself).
    7.33  
    7.34    \end{description}
    7.35 @@ -169,14 +169,14 @@
    7.36  
    7.37    \begin{description}
    7.38  
    7.39 -  \item @{text "@{theory}"} refers to the background theory of the
    7.40 +  \<^descr> @{text "@{theory}"} refers to the background theory of the
    7.41    current context --- as abstract value.
    7.42  
    7.43 -  \item @{text "@{theory A}"} refers to an explicitly named ancestor
    7.44 +  \<^descr> @{text "@{theory A}"} refers to an explicitly named ancestor
    7.45    theory @{text "A"} of the background theory of the current context
    7.46    --- as abstract value.
    7.47  
    7.48 -  \item @{text "@{theory_context A}"} is similar to @{text "@{theory
    7.49 +  \<^descr> @{text "@{theory_context A}"} is similar to @{text "@{theory
    7.50    A}"}, but presents the result as initial @{ML_type Proof.context}
    7.51    (see also @{ML Proof_Context.init_global}).
    7.52  
    7.53 @@ -222,15 +222,15 @@
    7.54  
    7.55    \begin{description}
    7.56  
    7.57 -  \item Type @{ML_type Proof.context} represents proof contexts.
    7.58 +  \<^descr> Type @{ML_type Proof.context} represents proof contexts.
    7.59  
    7.60 -  \item @{ML Proof_Context.init_global}~@{text "thy"} produces a proof
    7.61 +  \<^descr> @{ML Proof_Context.init_global}~@{text "thy"} produces a proof
    7.62    context derived from @{text "thy"}, initializing all data.
    7.63  
    7.64 -  \item @{ML Proof_Context.theory_of}~@{text "ctxt"} selects the
    7.65 +  \<^descr> @{ML Proof_Context.theory_of}~@{text "ctxt"} selects the
    7.66    background theory from @{text "ctxt"}.
    7.67  
    7.68 -  \item @{ML Proof_Context.transfer}~@{text "thy ctxt"} promotes the
    7.69 +  \<^descr> @{ML Proof_Context.transfer}~@{text "thy ctxt"} promotes the
    7.70    background theory of @{text "ctxt"} to the super theory @{text
    7.71    "thy"}.
    7.72  
    7.73 @@ -244,7 +244,7 @@
    7.74  
    7.75    \begin{description}
    7.76  
    7.77 -  \item @{text "@{context}"} refers to \emph{the} context at
    7.78 +  \<^descr> @{text "@{context}"} refers to \emph{the} context at
    7.79    compile-time --- as abstract value.  Independently of (local) theory
    7.80    or proof mode, this always produces a meaningful result.
    7.81  
    7.82 @@ -281,15 +281,15 @@
    7.83  
    7.84    \begin{description}
    7.85  
    7.86 -  \item Type @{ML_type Context.generic} is the direct sum of @{ML_type
    7.87 +  \<^descr> Type @{ML_type Context.generic} is the direct sum of @{ML_type
    7.88    "theory"} and @{ML_type "Proof.context"}, with the datatype
    7.89    constructors @{ML "Context.Theory"} and @{ML "Context.Proof"}.
    7.90  
    7.91 -  \item @{ML Context.theory_of}~@{text "context"} always produces a
    7.92 +  \<^descr> @{ML Context.theory_of}~@{text "context"} always produces a
    7.93    theory from the generic @{text "context"}, using @{ML
    7.94    "Proof_Context.theory_of"} as required.
    7.95  
    7.96 -  \item @{ML Context.proof_of}~@{text "context"} always produces a
    7.97 +  \<^descr> @{ML Context.proof_of}~@{text "context"} always produces a
    7.98    proof context from the generic @{text "context"}, using @{ML
    7.99    "Proof_Context.init_global"} as required (note that this re-initializes the
   7.100    context data with each invocation).
   7.101 @@ -385,15 +385,15 @@
   7.102  
   7.103    \begin{description}
   7.104  
   7.105 -  \item @{ML_functor Theory_Data}@{text "(spec)"} declares data for
   7.106 +  \<^descr> @{ML_functor Theory_Data}@{text "(spec)"} declares data for
   7.107    type @{ML_type theory} according to the specification provided as
   7.108    argument structure.  The resulting structure provides data init and
   7.109    access operations as described above.
   7.110  
   7.111 -  \item @{ML_functor Proof_Data}@{text "(spec)"} is analogous to
   7.112 +  \<^descr> @{ML_functor Proof_Data}@{text "(spec)"} is analogous to
   7.113    @{ML_functor Theory_Data} for type @{ML_type Proof.context}.
   7.114  
   7.115 -  \item @{ML_functor Generic_Data}@{text "(spec)"} is analogous to
   7.116 +  \<^descr> @{ML_functor Generic_Data}@{text "(spec)"} is analogous to
   7.117    @{ML_functor Theory_Data} for type @{ML_type Context.generic}.
   7.118  
   7.119    \end{description}
   7.120 @@ -546,13 +546,13 @@
   7.121  
   7.122    \begin{description}
   7.123  
   7.124 -  \item @{ML Config.get}~@{text "ctxt config"} gets the value of
   7.125 +  \<^descr> @{ML Config.get}~@{text "ctxt config"} gets the value of
   7.126    @{text "config"} in the given context.
   7.127  
   7.128 -  \item @{ML Config.map}~@{text "config f ctxt"} updates the context
   7.129 +  \<^descr> @{ML Config.map}~@{text "config f ctxt"} updates the context
   7.130    by updating the value of @{text "config"}.
   7.131  
   7.132 -  \item @{text "config ="}~@{ML Attrib.setup_config_bool}~@{text "name
   7.133 +  \<^descr> @{text "config ="}~@{ML Attrib.setup_config_bool}~@{text "name
   7.134    default"} creates a named configuration option of type @{ML_type
   7.135    bool}, with the given @{text "default"} depending on the application
   7.136    context.  The resulting @{text "config"} can be used to get/map its
   7.137 @@ -560,7 +560,7 @@
   7.138    background theory that registers the option as attribute with some
   7.139    concrete syntax.
   7.140  
   7.141 -  \item @{ML Attrib.config_int}, @{ML Attrib.config_real}, and @{ML
   7.142 +  \<^descr> @{ML Attrib.config_int}, @{ML Attrib.config_real}, and @{ML
   7.143    Attrib.config_string} work like @{ML Attrib.config_bool}, but for
   7.144    types @{ML_type int} and @{ML_type string}, respectively.
   7.145  
   7.146 @@ -692,25 +692,25 @@
   7.147  
   7.148    \begin{description}
   7.149  
   7.150 -  \item @{ML Name.internal}~@{text "name"} produces an internal name
   7.151 +  \<^descr> @{ML Name.internal}~@{text "name"} produces an internal name
   7.152    by adding one underscore.
   7.153  
   7.154 -  \item @{ML Name.skolem}~@{text "name"} produces a Skolem name by
   7.155 +  \<^descr> @{ML Name.skolem}~@{text "name"} produces a Skolem name by
   7.156    adding two underscores.
   7.157  
   7.158 -  \item Type @{ML_type Name.context} represents the context of already
   7.159 +  \<^descr> Type @{ML_type Name.context} represents the context of already
   7.160    used names; the initial value is @{ML "Name.context"}.
   7.161  
   7.162 -  \item @{ML Name.declare}~@{text "name"} enters a used name into the
   7.163 +  \<^descr> @{ML Name.declare}~@{text "name"} enters a used name into the
   7.164    context.
   7.165  
   7.166 -  \item @{ML Name.invent}~@{text "context name n"} produces @{text
   7.167 +  \<^descr> @{ML Name.invent}~@{text "context name n"} produces @{text
   7.168    "n"} fresh names derived from @{text "name"}.
   7.169  
   7.170 -  \item @{ML Name.variant}~@{text "name context"} produces a fresh
   7.171 +  \<^descr> @{ML Name.variant}~@{text "name context"} produces a fresh
   7.172    variant of @{text "name"}; the result is declared to the context.
   7.173  
   7.174 -  \item @{ML Variable.names_of}~@{text "ctxt"} retrieves the context
   7.175 +  \<^descr> @{ML Variable.names_of}~@{text "ctxt"} retrieves the context
   7.176    of declared type and term variable names.  Projecting a proof
   7.177    context down to a primitive name context is occasionally useful when
   7.178    invoking lower-level operations.  Regular management of ``fresh
   7.179 @@ -800,7 +800,7 @@
   7.180  
   7.181    \begin{description}
   7.182  
   7.183 -  \item Type @{ML_type indexname} represents indexed names.  This is
   7.184 +  \<^descr> Type @{ML_type indexname} represents indexed names.  This is
   7.185    an abbreviation for @{ML_type "string * int"}.  The second component
   7.186    is usually non-negative, except for situations where @{text "(x,
   7.187    -1)"} is used to inject basic names into this type.  Other negative
   7.188 @@ -845,16 +845,16 @@
   7.189  
   7.190    \begin{description}
   7.191  
   7.192 -  \item @{ML Long_Name.base_name}~@{text "name"} returns the base name
   7.193 +  \<^descr> @{ML Long_Name.base_name}~@{text "name"} returns the base name
   7.194    of a long name.
   7.195  
   7.196 -  \item @{ML Long_Name.qualifier}~@{text "name"} returns the qualifier
   7.197 +  \<^descr> @{ML Long_Name.qualifier}~@{text "name"} returns the qualifier
   7.198    of a long name.
   7.199  
   7.200 -  \item @{ML Long_Name.append}~@{text "name\<^sub>1 name\<^sub>2"} appends two long
   7.201 +  \<^descr> @{ML Long_Name.append}~@{text "name\<^sub>1 name\<^sub>2"} appends two long
   7.202    names.
   7.203  
   7.204 -  \item @{ML Long_Name.implode}~@{text "names"} and @{ML
   7.205 +  \<^descr> @{ML Long_Name.implode}~@{text "names"} and @{ML
   7.206    Long_Name.explode}~@{text "name"} convert between the packed string
   7.207    representation and the explicit list form of long names.
   7.208  
   7.209 @@ -949,66 +949,66 @@
   7.210  
   7.211    \begin{description}
   7.212  
   7.213 -  \item Type @{ML_type binding} represents the abstract concept of
   7.214 +  \<^descr> Type @{ML_type binding} represents the abstract concept of
   7.215    name bindings.
   7.216  
   7.217 -  \item @{ML Binding.empty} is the empty binding.
   7.218 +  \<^descr> @{ML Binding.empty} is the empty binding.
   7.219  
   7.220 -  \item @{ML Binding.name}~@{text "name"} produces a binding with base
   7.221 +  \<^descr> @{ML Binding.name}~@{text "name"} produces a binding with base
   7.222    name @{text "name"}.  Note that this lacks proper source position
   7.223    information; see also the ML antiquotation @{ML_antiquotation
   7.224    binding}.
   7.225  
   7.226 -  \item @{ML Binding.qualify}~@{text "mandatory name binding"}
   7.227 +  \<^descr> @{ML Binding.qualify}~@{text "mandatory name binding"}
   7.228    prefixes qualifier @{text "name"} to @{text "binding"}.  The @{text
   7.229    "mandatory"} flag tells if this name component always needs to be
   7.230    given in name space accesses --- this is mostly @{text "false"} in
   7.231    practice.  Note that this part of qualification is typically used in
   7.232    derived specification mechanisms.
   7.233  
   7.234 -  \item @{ML Binding.prefix} is similar to @{ML Binding.qualify}, but
   7.235 +  \<^descr> @{ML Binding.prefix} is similar to @{ML Binding.qualify}, but
   7.236    affects the system prefix.  This part of extra qualification is
   7.237    typically used in the infrastructure for modular specifications,
   7.238    notably ``local theory targets'' (see also \chref{ch:local-theory}).
   7.239  
   7.240 -  \item @{ML Binding.concealed}~@{text "binding"} indicates that the
   7.241 +  \<^descr> @{ML Binding.concealed}~@{text "binding"} indicates that the
   7.242    binding shall refer to an entity that serves foundational purposes
   7.243    only.  This flag helps to mark implementation details of
   7.244    specification mechanism etc.  Other tools should not depend on the
   7.245    particulars of concealed entities (cf.\ @{ML
   7.246    Name_Space.is_concealed}).
   7.247  
   7.248 -  \item @{ML Binding.print}~@{text "binding"} produces a string
   7.249 +  \<^descr> @{ML Binding.print}~@{text "binding"} produces a string
   7.250    representation for human-readable output, together with some formal
   7.251    markup that might get used in GUI front-ends, for example.
   7.252  
   7.253 -  \item Type @{ML_type Name_Space.naming} represents the abstract
   7.254 +  \<^descr> Type @{ML_type Name_Space.naming} represents the abstract
   7.255    concept of a naming policy.
   7.256  
   7.257 -  \item @{ML Name_Space.global_naming} is the default naming policy: it is
   7.258 +  \<^descr> @{ML Name_Space.global_naming} is the default naming policy: it is
   7.259    global and lacks any path prefix.  In a regular theory context this is
   7.260    augmented by a path prefix consisting of the theory name.
   7.261  
   7.262 -  \item @{ML Name_Space.add_path}~@{text "path naming"} augments the
   7.263 +  \<^descr> @{ML Name_Space.add_path}~@{text "path naming"} augments the
   7.264    naming policy by extending its path component.
   7.265  
   7.266 -  \item @{ML Name_Space.full_name}~@{text "naming binding"} turns a
   7.267 +  \<^descr> @{ML Name_Space.full_name}~@{text "naming binding"} turns a
   7.268    name binding (usually a basic name) into the fully qualified
   7.269    internal name, according to the given naming policy.
   7.270  
   7.271 -  \item Type @{ML_type Name_Space.T} represents name spaces.
   7.272 +  \<^descr> Type @{ML_type Name_Space.T} represents name spaces.
   7.273  
   7.274 -  \item @{ML Name_Space.empty}~@{text "kind"} and @{ML Name_Space.merge}~@{text
   7.275 +  \<^descr> @{ML Name_Space.empty}~@{text "kind"} and @{ML Name_Space.merge}~@{text
   7.276    "(space\<^sub>1, space\<^sub>2)"} are the canonical operations for
   7.277    maintaining name spaces according to theory data management
   7.278    (\secref{sec:context-data}); @{text "kind"} is a formal comment
   7.279    to characterize the purpose of a name space.
   7.280  
   7.281 -  \item @{ML Name_Space.declare}~@{text "context strict binding
   7.282 +  \<^descr> @{ML Name_Space.declare}~@{text "context strict binding
   7.283    space"} enters a name binding as fully qualified internal name into
   7.284    the name space, using the naming of the context.
   7.285  
   7.286 -  \item @{ML Name_Space.intern}~@{text "space name"} internalizes a
   7.287 +  \<^descr> @{ML Name_Space.intern}~@{text "space name"} internalizes a
   7.288    (partially qualified) external name.
   7.289  
   7.290    This operation is mostly for parsing!  Note that fully qualified
   7.291 @@ -1017,13 +1017,13 @@
   7.292    (or their derivatives for @{ML_type theory} and
   7.293    @{ML_type Proof.context}).
   7.294  
   7.295 -  \item @{ML Name_Space.extern}~@{text "ctxt space name"} externalizes a
   7.296 +  \<^descr> @{ML Name_Space.extern}~@{text "ctxt space name"} externalizes a
   7.297    (fully qualified) internal name.
   7.298  
   7.299    This operation is mostly for printing!  User code should not rely on
   7.300    the precise result too much.
   7.301  
   7.302 -  \item @{ML Name_Space.is_concealed}~@{text "space name"} indicates
   7.303 +  \<^descr> @{ML Name_Space.is_concealed}~@{text "space name"} indicates
   7.304    whether @{text "name"} refers to a strictly private entity that
   7.305    other tools are supposed to ignore!
   7.306  
   7.307 @@ -1041,7 +1041,7 @@
   7.308  
   7.309    \begin{description}
   7.310  
   7.311 -  \item @{text "@{binding name}"} produces a binding with base name
   7.312 +  \<^descr> @{text "@{binding name}"} produces a binding with base name
   7.313    @{text "name"} and the source position taken from the concrete
   7.314    syntax of this antiquotation.  In many situations this is more
   7.315    appropriate than the more basic @{ML Binding.name} function.
     8.1 --- a/src/Doc/Implementation/Proof.thy	Wed Oct 14 15:06:42 2015 +0200
     8.2 +++ b/src/Doc/Implementation/Proof.thy	Wed Oct 14 15:10:32 2015 +0200
     8.3 @@ -116,45 +116,45 @@
     8.4  
     8.5    \begin{description}
     8.6  
     8.7 -  \item @{ML Variable.add_fixes}~@{text "xs ctxt"} fixes term
     8.8 +  \<^descr> @{ML Variable.add_fixes}~@{text "xs ctxt"} fixes term
     8.9    variables @{text "xs"}, returning the resulting internal names.  By
    8.10    default, the internal representation coincides with the external
    8.11    one, which also means that the given variables must not be fixed
    8.12    already.  There is a different policy within a local proof body: the
    8.13    given names are just hints for newly invented Skolem variables.
    8.14  
    8.15 -  \item @{ML Variable.variant_fixes} is similar to @{ML
    8.16 +  \<^descr> @{ML Variable.variant_fixes} is similar to @{ML
    8.17    Variable.add_fixes}, but always produces fresh variants of the given
    8.18    names.
    8.19  
    8.20 -  \item @{ML Variable.declare_term}~@{text "t ctxt"} declares term
    8.21 +  \<^descr> @{ML Variable.declare_term}~@{text "t ctxt"} declares term
    8.22    @{text "t"} to belong to the context.  This automatically fixes new
    8.23    type variables, but not term variables.  Syntactic constraints for
    8.24    type and term variables are declared uniformly, though.
    8.25  
    8.26 -  \item @{ML Variable.declare_constraints}~@{text "t ctxt"} declares
    8.27 +  \<^descr> @{ML Variable.declare_constraints}~@{text "t ctxt"} declares
    8.28    syntactic constraints from term @{text "t"}, without making it part
    8.29    of the context yet.
    8.30  
    8.31 -  \item @{ML Variable.export}~@{text "inner outer thms"} generalizes
    8.32 +  \<^descr> @{ML Variable.export}~@{text "inner outer thms"} generalizes
    8.33    fixed type and term variables in @{text "thms"} according to the
    8.34    difference of the @{text "inner"} and @{text "outer"} context,
    8.35    following the principles sketched above.
    8.36  
    8.37 -  \item @{ML Variable.polymorphic}~@{text "ctxt ts"} generalizes type
    8.38 +  \<^descr> @{ML Variable.polymorphic}~@{text "ctxt ts"} generalizes type
    8.39    variables in @{text "ts"} as far as possible, even those occurring
    8.40    in fixed term variables.  The default policy of type-inference is to
    8.41    fix newly introduced type variables, which is essentially reversed
    8.42    with @{ML Variable.polymorphic}: here the given terms are detached
    8.43    from the context as far as possible.
    8.44  
    8.45 -  \item @{ML Variable.import}~@{text "open thms ctxt"} invents fixed
    8.46 +  \<^descr> @{ML Variable.import}~@{text "open thms ctxt"} invents fixed
    8.47    type and term variables for the schematic ones occurring in @{text
    8.48    "thms"}.  The @{text "open"} flag indicates whether the fixed names
    8.49    should be accessible to the user, otherwise newly introduced names
    8.50    are marked as ``internal'' (\secref{sec:names}).
    8.51  
    8.52 -  \item @{ML Variable.focus}~@{text "bindings B"} decomposes the outermost @{text
    8.53 +  \<^descr> @{ML Variable.focus}~@{text "bindings B"} decomposes the outermost @{text
    8.54    "\<And>"} prefix of proposition @{text "B"}, using the given name bindings.
    8.55  
    8.56    \end{description}
    8.57 @@ -293,27 +293,27 @@
    8.58  
    8.59    \begin{description}
    8.60  
    8.61 -  \item Type @{ML_type Assumption.export} represents arbitrary export
    8.62 +  \<^descr> Type @{ML_type Assumption.export} represents arbitrary export
    8.63    rules, which is any function of type @{ML_type "bool -> cterm list
    8.64    -> thm -> thm"}, where the @{ML_type "bool"} indicates goal mode,
    8.65    and the @{ML_type "cterm list"} the collection of assumptions to be
    8.66    discharged simultaneously.
    8.67  
    8.68 -  \item @{ML Assumption.assume}~@{text "ctxt A"} turns proposition @{text
    8.69 +  \<^descr> @{ML Assumption.assume}~@{text "ctxt A"} turns proposition @{text
    8.70    "A"} into a primitive assumption @{text "A \<turnstile> A'"}, where the
    8.71    conclusion @{text "A'"} is in HHF normal form.
    8.72  
    8.73 -  \item @{ML Assumption.add_assms}~@{text "r As"} augments the context
    8.74 +  \<^descr> @{ML Assumption.add_assms}~@{text "r As"} augments the context
    8.75    by assumptions @{text "As"} with export rule @{text "r"}.  The
    8.76    resulting facts are hypothetical theorems as produced by the raw
    8.77    @{ML Assumption.assume}.
    8.78  
    8.79 -  \item @{ML Assumption.add_assumes}~@{text "As"} is a special case of
    8.80 +  \<^descr> @{ML Assumption.add_assumes}~@{text "As"} is a special case of
    8.81    @{ML Assumption.add_assms} where the export rule performs @{text
    8.82    "\<Longrightarrow>\<hyphen>intro"} or @{text "#\<Longrightarrow>\<hyphen>intro"}, depending on goal
    8.83    mode.
    8.84  
    8.85 -  \item @{ML Assumption.export}~@{text "is_goal inner outer thm"}
    8.86 +  \<^descr> @{ML Assumption.export}~@{text "is_goal inner outer thm"}
    8.87    exports result @{text "thm"} from the the @{text "inner"} context
    8.88    back into the @{text "outer"} one; @{text "is_goal = true"} means
    8.89    this is a goal context.  The result is in HHF normal form.  Note
    8.90 @@ -421,31 +421,31 @@
    8.91  
    8.92    \begin{description}
    8.93  
    8.94 -  \item @{ML SUBPROOF}~@{text "tac ctxt i"} decomposes the structure
    8.95 +  \<^descr> @{ML SUBPROOF}~@{text "tac ctxt i"} decomposes the structure
    8.96    of the specified sub-goal, producing an extended context and a
    8.97    reduced goal, which needs to be solved by the given tactic.  All
    8.98    schematic parameters of the goal are imported into the context as
    8.99    fixed ones, which may not be instantiated in the sub-proof.
   8.100  
   8.101 -  \item @{ML Subgoal.FOCUS}, @{ML Subgoal.FOCUS_PREMS}, and @{ML
   8.102 +  \<^descr> @{ML Subgoal.FOCUS}, @{ML Subgoal.FOCUS_PREMS}, and @{ML
   8.103    Subgoal.FOCUS_PARAMS} are similar to @{ML SUBPROOF}, but are
   8.104    slightly more flexible: only the specified parts of the subgoal are
   8.105    imported into the context, and the body tactic may introduce new
   8.106    subgoals and schematic variables.
   8.107  
   8.108 -  \item @{ML Subgoal.focus}, @{ML Subgoal.focus_prems}, @{ML
   8.109 +  \<^descr> @{ML Subgoal.focus}, @{ML Subgoal.focus_prems}, @{ML
   8.110    Subgoal.focus_params} extract the focus information from a goal
   8.111    state in the same way as the corresponding tacticals above.  This is
   8.112    occasionally useful to experiment without writing actual tactics
   8.113    yet.
   8.114  
   8.115 -  \item @{ML Goal.prove}~@{text "ctxt xs As C tac"} states goal @{text
   8.116 +  \<^descr> @{ML Goal.prove}~@{text "ctxt xs As C tac"} states goal @{text
   8.117    "C"} in the context augmented by fixed variables @{text "xs"} and
   8.118    assumptions @{text "As"}, and applies tactic @{text "tac"} to solve
   8.119    it.  The latter may depend on the local assumptions being presented
   8.120    as facts.  The result is in HHF normal form.
   8.121  
   8.122 -  \item @{ML Goal.prove_common}~@{text "ctxt fork_pri"} is the common form
   8.123 +  \<^descr> @{ML Goal.prove_common}~@{text "ctxt fork_pri"} is the common form
   8.124    to state and prove a simultaneous goal statement, where @{ML Goal.prove}
   8.125    is a convenient shorthand that is most frequently used in applications.
   8.126  
   8.127 @@ -462,7 +462,7 @@
   8.128    transaction. Thus the system is able to expose error messages ultimately
   8.129    to the end-user, even though the subsequent ML code misses them.
   8.130  
   8.131 -  \item @{ML Obtain.result}~@{text "tac thms ctxt"} eliminates the
   8.132 +  \<^descr> @{ML Obtain.result}~@{text "tac thms ctxt"} eliminates the
   8.133    given facts using a tactic, which results in additional fixed
   8.134    variables and assumptions in the context.  Final results need to be
   8.135    exported explicitly.
     9.1 --- a/src/Doc/Implementation/Syntax.thy	Wed Oct 14 15:06:42 2015 +0200
     9.2 +++ b/src/Doc/Implementation/Syntax.thy	Wed Oct 14 15:10:32 2015 +0200
     9.3 @@ -90,10 +90,10 @@
     9.4  
     9.5    \begin{description}
     9.6  
     9.7 -  \item @{ML Syntax.read_typs}~@{text "ctxt strs"} parses and checks a
     9.8 +  \<^descr> @{ML Syntax.read_typs}~@{text "ctxt strs"} parses and checks a
     9.9    simultaneous list of source strings as types of the logic.
    9.10  
    9.11 -  \item @{ML Syntax.read_terms}~@{text "ctxt strs"} parses and checks a
    9.12 +  \<^descr> @{ML Syntax.read_terms}~@{text "ctxt strs"} parses and checks a
    9.13    simultaneous list of source strings as terms of the logic.
    9.14    Type-reconstruction puts all parsed terms into the same scope: types of
    9.15    free variables ultimately need to coincide.
    9.16 @@ -103,26 +103,26 @@
    9.17    is possible to use @{ML Type.constraint} on the intermediate pre-terms
    9.18    (\secref{sec:term-check}).
    9.19  
    9.20 -  \item @{ML Syntax.read_props}~@{text "ctxt strs"} parses and checks a
    9.21 +  \<^descr> @{ML Syntax.read_props}~@{text "ctxt strs"} parses and checks a
    9.22    simultaneous list of source strings as terms of the logic, with an implicit
    9.23    type-constraint for each argument to enforce type @{typ prop}; this also
    9.24    affects the inner syntax for parsing. The remaining type-reconstruction
    9.25    works as for @{ML Syntax.read_terms}.
    9.26  
    9.27 -  \item @{ML Syntax.read_typ}, @{ML Syntax.read_term}, @{ML Syntax.read_prop}
    9.28 +  \<^descr> @{ML Syntax.read_typ}, @{ML Syntax.read_term}, @{ML Syntax.read_prop}
    9.29    are like the simultaneous versions, but operate on a single argument only.
    9.30    This convenient shorthand is adequate in situations where a single item in
    9.31    its own scope is processed. Do not use @{ML "map o Syntax.read_term"} where
    9.32    @{ML Syntax.read_terms} is actually intended!
    9.33  
    9.34 -  \item @{ML Syntax.pretty_typ}~@{text "ctxt T"} and @{ML
    9.35 +  \<^descr> @{ML Syntax.pretty_typ}~@{text "ctxt T"} and @{ML
    9.36    Syntax.pretty_term}~@{text "ctxt t"} uncheck and pretty-print the given type
    9.37    or term, respectively. Although the uncheck phase acts on a simultaneous
    9.38    list as well, this is rarely used in practice, so only the singleton case is
    9.39    provided as combined pretty operation. There is no distinction of term vs.\
    9.40    proposition.
    9.41  
    9.42 -  \item @{ML Syntax.string_of_typ} and @{ML Syntax.string_of_term} are
    9.43 +  \<^descr> @{ML Syntax.string_of_typ} and @{ML Syntax.string_of_term} are
    9.44    convenient compositions of @{ML Syntax.pretty_typ} and @{ML
    9.45    Syntax.pretty_term} with @{ML Pretty.string_of} for output. The result may
    9.46    be concatenated with other strings, as long as there is no further
    9.47 @@ -181,22 +181,22 @@
    9.48  
    9.49    \begin{description}
    9.50  
    9.51 -  \item @{ML Syntax.parse_typ}~@{text "ctxt str"} parses a source string as
    9.52 +  \<^descr> @{ML Syntax.parse_typ}~@{text "ctxt str"} parses a source string as
    9.53    pre-type that is ready to be used with subsequent check operations.
    9.54  
    9.55 -  \item @{ML Syntax.parse_term}~@{text "ctxt str"} parses a source string as
    9.56 +  \<^descr> @{ML Syntax.parse_term}~@{text "ctxt str"} parses a source string as
    9.57    pre-term that is ready to be used with subsequent check operations.
    9.58  
    9.59 -  \item @{ML Syntax.parse_prop}~@{text "ctxt str"} parses a source string as
    9.60 +  \<^descr> @{ML Syntax.parse_prop}~@{text "ctxt str"} parses a source string as
    9.61    pre-term that is ready to be used with subsequent check operations. The
    9.62    inner syntax category is @{typ prop} and a suitable type-constraint is
    9.63    included to ensure that this information is observed in subsequent type
    9.64    reconstruction.
    9.65  
    9.66 -  \item @{ML Syntax.unparse_typ}~@{text "ctxt T"} unparses a type after
    9.67 +  \<^descr> @{ML Syntax.unparse_typ}~@{text "ctxt T"} unparses a type after
    9.68    uncheck operations, to turn it into a pretty tree.
    9.69  
    9.70 -  \item @{ML Syntax.unparse_term}~@{text "ctxt T"} unparses a term after
    9.71 +  \<^descr> @{ML Syntax.unparse_term}~@{text "ctxt T"} unparses a term after
    9.72    uncheck operations, to turn it into a pretty tree. There is no distinction
    9.73    for propositions here.
    9.74  
    9.75 @@ -249,11 +249,11 @@
    9.76  
    9.77    \begin{description}
    9.78  
    9.79 -  \item @{ML Syntax.check_typs}~@{text "ctxt Ts"} checks a simultaneous list
    9.80 +  \<^descr> @{ML Syntax.check_typs}~@{text "ctxt Ts"} checks a simultaneous list
    9.81    of pre-types as types of the logic.  Typically, this involves normalization
    9.82    of type synonyms.
    9.83  
    9.84 -  \item @{ML Syntax.check_terms}~@{text "ctxt ts"} checks a simultaneous list
    9.85 +  \<^descr> @{ML Syntax.check_terms}~@{text "ctxt ts"} checks a simultaneous list
    9.86    of pre-terms as terms of the logic. Typically, this involves type-inference
    9.87    and normalization term abbreviations. The types within the given terms are
    9.88    treated in the same way as for @{ML Syntax.check_typs}.
    9.89 @@ -264,15 +264,15 @@
    9.90    is checked; afterwards the type arguments are recovered with @{ML
    9.91    Logic.dest_type}.
    9.92  
    9.93 -  \item @{ML Syntax.check_props}~@{text "ctxt ts"} checks a simultaneous list
    9.94 +  \<^descr> @{ML Syntax.check_props}~@{text "ctxt ts"} checks a simultaneous list
    9.95    of pre-terms as terms of the logic, such that all terms are constrained by
    9.96    type @{typ prop}. The remaining check operation works as @{ML
    9.97    Syntax.check_terms} above.
    9.98  
    9.99 -  \item @{ML Syntax.uncheck_typs}~@{text "ctxt Ts"} unchecks a simultaneous
   9.100 +  \<^descr> @{ML Syntax.uncheck_typs}~@{text "ctxt Ts"} unchecks a simultaneous
   9.101    list of types of the logic, in preparation of pretty printing.
   9.102  
   9.103 -  \item @{ML Syntax.uncheck_terms}~@{text "ctxt ts"} unchecks a simultaneous
   9.104 +  \<^descr> @{ML Syntax.uncheck_terms}~@{text "ctxt ts"} unchecks a simultaneous
   9.105    list of terms of the logic, in preparation of pretty printing. There is no
   9.106    distinction for propositions here.
   9.107  
    10.1 --- a/src/Doc/Implementation/Tactic.thy	Wed Oct 14 15:06:42 2015 +0200
    10.2 +++ b/src/Doc/Implementation/Tactic.thy	Wed Oct 14 15:10:32 2015 +0200
    10.3 @@ -72,19 +72,19 @@
    10.4  
    10.5    \begin{description}
    10.6  
    10.7 -  \item @{ML "Goal.init"}~@{text C} initializes a tactical goal from
    10.8 +  \<^descr> @{ML "Goal.init"}~@{text C} initializes a tactical goal from
    10.9    the well-formed proposition @{text C}.
   10.10  
   10.11 -  \item @{ML "Goal.finish"}~@{text "ctxt thm"} checks whether theorem
   10.12 +  \<^descr> @{ML "Goal.finish"}~@{text "ctxt thm"} checks whether theorem
   10.13    @{text "thm"} is a solved goal (no subgoals), and concludes the
   10.14    result by removing the goal protection.  The context is only
   10.15    required for printing error messages.
   10.16  
   10.17 -  \item @{ML "Goal.protect"}~@{text "n thm"} protects the statement
   10.18 +  \<^descr> @{ML "Goal.protect"}~@{text "n thm"} protects the statement
   10.19    of theorem @{text "thm"}.  The parameter @{text n} indicates the
   10.20    number of premises to be retained.
   10.21  
   10.22 -  \item @{ML "Goal.conclude"}~@{text "thm"} removes the goal
   10.23 +  \<^descr> @{ML "Goal.conclude"}~@{text "thm"} removes the goal
   10.24    protection, even if there are pending subgoals.
   10.25  
   10.26    \end{description}
   10.27 @@ -189,48 +189,48 @@
   10.28  
   10.29    \begin{description}
   10.30  
   10.31 -  \item Type @{ML_type tactic} represents tactics.  The
   10.32 +  \<^descr> Type @{ML_type tactic} represents tactics.  The
   10.33    well-formedness conditions described above need to be observed.  See
   10.34    also @{file "~~/src/Pure/General/seq.ML"} for the underlying
   10.35    implementation of lazy sequences.
   10.36  
   10.37 -  \item Type @{ML_type "int -> tactic"} represents tactics with
   10.38 +  \<^descr> Type @{ML_type "int -> tactic"} represents tactics with
   10.39    explicit subgoal addressing, with well-formedness conditions as
   10.40    described above.
   10.41  
   10.42 -  \item @{ML no_tac} is a tactic that always fails, returning the
   10.43 +  \<^descr> @{ML no_tac} is a tactic that always fails, returning the
   10.44    empty sequence.
   10.45  
   10.46 -  \item @{ML all_tac} is a tactic that always succeeds, returning a
   10.47 +  \<^descr> @{ML all_tac} is a tactic that always succeeds, returning a
   10.48    singleton sequence with unchanged goal state.
   10.49  
   10.50 -  \item @{ML print_tac}~@{text "ctxt message"} is like @{ML all_tac}, but
   10.51 +  \<^descr> @{ML print_tac}~@{text "ctxt message"} is like @{ML all_tac}, but
   10.52    prints a message together with the goal state on the tracing
   10.53    channel.
   10.54  
   10.55 -  \item @{ML PRIMITIVE}~@{text rule} turns a primitive inference rule
   10.56 +  \<^descr> @{ML PRIMITIVE}~@{text rule} turns a primitive inference rule
   10.57    into a tactic with unique result.  Exception @{ML THM} is considered
   10.58    a regular tactic failure and produces an empty result; other
   10.59    exceptions are passed through.
   10.60  
   10.61 -  \item @{ML SUBGOAL}~@{text "(fn (subgoal, i) => tactic)"} is the
   10.62 +  \<^descr> @{ML SUBGOAL}~@{text "(fn (subgoal, i) => tactic)"} is the
   10.63    most basic form to produce a tactic with subgoal addressing.  The
   10.64    given abstraction over the subgoal term and subgoal number allows to
   10.65    peek at the relevant information of the full goal state.  The
   10.66    subgoal range is checked as required above.
   10.67  
   10.68 -  \item @{ML CSUBGOAL} is similar to @{ML SUBGOAL}, but passes the
   10.69 +  \<^descr> @{ML CSUBGOAL} is similar to @{ML SUBGOAL}, but passes the
   10.70    subgoal as @{ML_type cterm} instead of raw @{ML_type term}.  This
   10.71    avoids expensive re-certification in situations where the subgoal is
   10.72    used directly for primitive inferences.
   10.73  
   10.74 -  \item @{ML SELECT_GOAL}~@{text "tac i"} confines a tactic to the
   10.75 +  \<^descr> @{ML SELECT_GOAL}~@{text "tac i"} confines a tactic to the
   10.76    specified subgoal @{text "i"}.  This rearranges subgoals and the
   10.77    main goal protection (\secref{sec:tactical-goals}), while retaining
   10.78    the syntactic context of the overall goal state (concerning
   10.79    schematic variables etc.).
   10.80  
   10.81 -  \item @{ML PREFER_GOAL}~@{text "tac i"} rearranges subgoals to put
   10.82 +  \<^descr> @{ML PREFER_GOAL}~@{text "tac i"} rearranges subgoals to put
   10.83    @{text "i"} in front.  This is similar to @{ML SELECT_GOAL}, but
   10.84    without changing the main goal protection.
   10.85  
   10.86 @@ -297,29 +297,29 @@
   10.87  
   10.88    \begin{description}
   10.89  
   10.90 -  \item @{ML resolve_tac}~@{text "ctxt thms i"} refines the goal state
   10.91 +  \<^descr> @{ML resolve_tac}~@{text "ctxt thms i"} refines the goal state
   10.92    using the given theorems, which should normally be introduction
   10.93    rules.  The tactic resolves a rule's conclusion with subgoal @{text
   10.94    i}, replacing it by the corresponding versions of the rule's
   10.95    premises.
   10.96  
   10.97 -  \item @{ML eresolve_tac}~@{text "ctxt thms i"} performs elim-resolution
   10.98 +  \<^descr> @{ML eresolve_tac}~@{text "ctxt thms i"} performs elim-resolution
   10.99    with the given theorems, which are normally be elimination rules.
  10.100  
  10.101    Note that @{ML_text "eresolve_tac ctxt [asm_rl]"} is equivalent to @{ML_text
  10.102    "assume_tac ctxt"}, which facilitates mixing of assumption steps with
  10.103    genuine eliminations.
  10.104  
  10.105 -  \item @{ML dresolve_tac}~@{text "ctxt thms i"} performs
  10.106 +  \<^descr> @{ML dresolve_tac}~@{text "ctxt thms i"} performs
  10.107    destruct-resolution with the given theorems, which should normally
  10.108    be destruction rules.  This replaces an assumption by the result of
  10.109    applying one of the rules.
  10.110  
  10.111 -  \item @{ML forward_tac} is like @{ML dresolve_tac} except that the
  10.112 +  \<^descr> @{ML forward_tac} is like @{ML dresolve_tac} except that the
  10.113    selected assumption is not deleted.  It applies a rule to an
  10.114    assumption, adding the result as a new assumption.
  10.115  
  10.116 -  \item @{ML biresolve_tac}~@{text "ctxt brls i"} refines the proof state
  10.117 +  \<^descr> @{ML biresolve_tac}~@{text "ctxt brls i"} refines the proof state
  10.118    by resolution or elim-resolution on each rule, as indicated by its
  10.119    flag.  It affects subgoal @{text "i"} of the proof state.
  10.120  
  10.121 @@ -329,16 +329,16 @@
  10.122    elimination rules, which is useful to organize the search process
  10.123    systematically in proof tools.
  10.124  
  10.125 -  \item @{ML assume_tac}~@{text "ctxt i"} attempts to solve subgoal @{text i}
  10.126 +  \<^descr> @{ML assume_tac}~@{text "ctxt i"} attempts to solve subgoal @{text i}
  10.127    by assumption (modulo higher-order unification).
  10.128  
  10.129 -  \item @{ML eq_assume_tac} is similar to @{ML assume_tac}, but checks
  10.130 +  \<^descr> @{ML eq_assume_tac} is similar to @{ML assume_tac}, but checks
  10.131    only for immediate @{text "\<alpha>"}-convertibility instead of using
  10.132    unification.  It succeeds (with a unique next state) if one of the
  10.133    assumptions is equal to the subgoal's conclusion.  Since it does not
  10.134    instantiate variables, it cannot make other subgoals unprovable.
  10.135  
  10.136 -  \item @{ML match_tac}, @{ML ematch_tac}, @{ML dmatch_tac}, and @{ML
  10.137 +  \<^descr> @{ML match_tac}, @{ML ematch_tac}, @{ML dmatch_tac}, and @{ML
  10.138    bimatch_tac} are similar to @{ML resolve_tac}, @{ML eresolve_tac},
  10.139    @{ML dresolve_tac}, and @{ML biresolve_tac}, respectively, but do
  10.140    not instantiate schematic variables in the goal state.%
  10.141 @@ -421,31 +421,31 @@
  10.142  
  10.143    \begin{description}
  10.144  
  10.145 -  \item @{ML Rule_Insts.res_inst_tac}~@{text "ctxt insts thm i"} instantiates the
  10.146 +  \<^descr> @{ML Rule_Insts.res_inst_tac}~@{text "ctxt insts thm i"} instantiates the
  10.147    rule @{text thm} with the instantiations @{text insts}, as described
  10.148    above, and then performs resolution on subgoal @{text i}.
  10.149    
  10.150 -  \item @{ML Rule_Insts.eres_inst_tac} is like @{ML Rule_Insts.res_inst_tac},
  10.151 +  \<^descr> @{ML Rule_Insts.eres_inst_tac} is like @{ML Rule_Insts.res_inst_tac},
  10.152    but performs elim-resolution.
  10.153  
  10.154 -  \item @{ML Rule_Insts.dres_inst_tac} is like @{ML Rule_Insts.res_inst_tac},
  10.155 +  \<^descr> @{ML Rule_Insts.dres_inst_tac} is like @{ML Rule_Insts.res_inst_tac},
  10.156    but performs destruct-resolution.
  10.157  
  10.158 -  \item @{ML Rule_Insts.forw_inst_tac} is like @{ML Rule_Insts.dres_inst_tac}
  10.159 +  \<^descr> @{ML Rule_Insts.forw_inst_tac} is like @{ML Rule_Insts.dres_inst_tac}
  10.160    except that the selected assumption is not deleted.
  10.161  
  10.162 -  \item @{ML Rule_Insts.subgoal_tac}~@{text "ctxt \<phi> i"} adds the proposition
  10.163 +  \<^descr> @{ML Rule_Insts.subgoal_tac}~@{text "ctxt \<phi> i"} adds the proposition
  10.164    @{text "\<phi>"} as local premise to subgoal @{text "i"}, and poses the
  10.165    same as a new subgoal @{text "i + 1"} (in the original context).
  10.166  
  10.167 -  \item @{ML Rule_Insts.thin_tac}~@{text "ctxt \<phi> i"} deletes the specified
  10.168 +  \<^descr> @{ML Rule_Insts.thin_tac}~@{text "ctxt \<phi> i"} deletes the specified
  10.169    premise from subgoal @{text i}.  Note that @{text \<phi>} may contain
  10.170    schematic variables, to abbreviate the intended proposition; the
  10.171    first matching subgoal premise will be deleted.  Removing useless
  10.172    premises from a subgoal increases its readability and can make
  10.173    search tactics run faster.
  10.174  
  10.175 -  \item @{ML rename_tac}~@{text "names i"} renames the innermost
  10.176 +  \<^descr> @{ML rename_tac}~@{text "names i"} renames the innermost
  10.177    parameters of subgoal @{text i} according to the provided @{text
  10.178    names} (which need to be distinct identifiers).
  10.179  
  10.180 @@ -475,14 +475,14 @@
  10.181  
  10.182    \begin{description}
  10.183  
  10.184 -  \item @{ML rotate_tac}~@{text "n i"} rotates the premises of subgoal
  10.185 +  \<^descr> @{ML rotate_tac}~@{text "n i"} rotates the premises of subgoal
  10.186    @{text i} by @{text n} positions: from right to left if @{text n} is
  10.187    positive, and from left to right if @{text n} is negative.
  10.188  
  10.189 -  \item @{ML distinct_subgoals_tac} removes duplicate subgoals from a
  10.190 +  \<^descr> @{ML distinct_subgoals_tac} removes duplicate subgoals from a
  10.191    proof state.  This is potentially inefficient.
  10.192  
  10.193 -  \item @{ML flexflex_tac} removes all flex-flex pairs from the proof
  10.194 +  \<^descr> @{ML flexflex_tac} removes all flex-flex pairs from the proof
  10.195    state by applying the trivial unifier.  This drastic step loses
  10.196    information.  It is already part of the Isar infrastructure for
  10.197    facts resulting from goals, and rarely needs to be invoked manually.
  10.198 @@ -515,7 +515,7 @@
  10.199  
  10.200    \begin{description}
  10.201  
  10.202 -  \item @{ML compose_tac}~@{text "ctxt (flag, rule, m) i"} refines subgoal
  10.203 +  \<^descr> @{ML compose_tac}~@{text "ctxt (flag, rule, m) i"} refines subgoal
  10.204    @{text "i"} using @{text "rule"}, without lifting.  The @{text
  10.205    "rule"} is taken to have the form @{text "\<psi>\<^sub>1 \<Longrightarrow> \<dots> \<psi>\<^sub>m \<Longrightarrow> \<psi>"}, where
  10.206    @{text "\<psi>"} need not be atomic; thus @{text "m"} determines the
  10.207 @@ -523,7 +523,7 @@
  10.208    performs elim-resolution --- it solves the first premise of @{text
  10.209    "rule"} by assumption and deletes that assumption.
  10.210  
  10.211 -  \item @{ML Drule.compose}~@{text "(thm\<^sub>1, i, thm\<^sub>2)"} uses @{text "thm\<^sub>1"},
  10.212 +  \<^descr> @{ML Drule.compose}~@{text "(thm\<^sub>1, i, thm\<^sub>2)"} uses @{text "thm\<^sub>1"},
  10.213    regarded as an atomic formula, to solve premise @{text "i"} of
  10.214    @{text "thm\<^sub>2"}.  Let @{text "thm\<^sub>1"} and @{text "thm\<^sub>2"} be @{text
  10.215    "\<psi>"} and @{text "\<phi>\<^sub>1 \<Longrightarrow> \<dots> \<phi>\<^sub>n \<Longrightarrow> \<phi>"}.  The unique @{text "s"} that
  10.216 @@ -531,7 +531,7 @@
  10.217    \<dots> \<phi>\<^sub>i\<^sub>-\<^sub>1 \<Longrightarrow> \<phi>\<^sub>i\<^sub>+\<^sub>1 \<Longrightarrow> \<dots> \<phi>\<^sub>n \<Longrightarrow> \<phi>)s"}.  Multiple results are considered as
  10.218    error (exception @{ML THM}).
  10.219  
  10.220 -  \item @{text "thm\<^sub>1 COMP thm\<^sub>2"} is the same as @{text "Drule.compose
  10.221 +  \<^descr> @{text "thm\<^sub>1 COMP thm\<^sub>2"} is the same as @{text "Drule.compose
  10.222    (thm\<^sub>1, 1, thm\<^sub>2)"}.
  10.223  
  10.224    \end{description}
  10.225 @@ -583,7 +583,7 @@
  10.226  
  10.227    \begin{description}
  10.228  
  10.229 -  \item @{text "tac\<^sub>1"}~@{ML_op THEN}~@{text "tac\<^sub>2"} is the sequential
  10.230 +  \<^descr> @{text "tac\<^sub>1"}~@{ML_op THEN}~@{text "tac\<^sub>2"} is the sequential
  10.231    composition of @{text "tac\<^sub>1"} and @{text "tac\<^sub>2"}.  Applied to a goal
  10.232    state, it returns all states reachable in two steps by applying
  10.233    @{text "tac\<^sub>1"} followed by @{text "tac\<^sub>2"}.  First, it applies @{text
  10.234 @@ -592,30 +592,30 @@
  10.235    concatenates the results to produce again one flat sequence of
  10.236    states.
  10.237  
  10.238 -  \item @{text "tac\<^sub>1"}~@{ML_op ORELSE}~@{text "tac\<^sub>2"} makes a choice
  10.239 +  \<^descr> @{text "tac\<^sub>1"}~@{ML_op ORELSE}~@{text "tac\<^sub>2"} makes a choice
  10.240    between @{text "tac\<^sub>1"} and @{text "tac\<^sub>2"}.  Applied to a state, it
  10.241    tries @{text "tac\<^sub>1"} and returns the result if non-empty; if @{text
  10.242    "tac\<^sub>1"} fails then it uses @{text "tac\<^sub>2"}.  This is a deterministic
  10.243    choice: if @{text "tac\<^sub>1"} succeeds then @{text "tac\<^sub>2"} is excluded
  10.244    from the result.
  10.245  
  10.246 -  \item @{text "tac\<^sub>1"}~@{ML_op APPEND}~@{text "tac\<^sub>2"} concatenates the
  10.247 +  \<^descr> @{text "tac\<^sub>1"}~@{ML_op APPEND}~@{text "tac\<^sub>2"} concatenates the
  10.248    possible results of @{text "tac\<^sub>1"} and @{text "tac\<^sub>2"}.  Unlike
  10.249    @{ML_op "ORELSE"} there is \emph{no commitment} to either tactic, so
  10.250    @{ML_op "APPEND"} helps to avoid incompleteness during search, at
  10.251    the cost of potential inefficiencies.
  10.252  
  10.253 -  \item @{ML EVERY}~@{text "[tac\<^sub>1, \<dots>, tac\<^sub>n]"} abbreviates @{text
  10.254 +  \<^descr> @{ML EVERY}~@{text "[tac\<^sub>1, \<dots>, tac\<^sub>n]"} abbreviates @{text
  10.255    "tac\<^sub>1"}~@{ML_op THEN}~@{text "\<dots>"}~@{ML_op THEN}~@{text "tac\<^sub>n"}.
  10.256    Note that @{ML "EVERY []"} is the same as @{ML all_tac}: it always
  10.257    succeeds.
  10.258  
  10.259 -  \item @{ML FIRST}~@{text "[tac\<^sub>1, \<dots>, tac\<^sub>n]"} abbreviates @{text
  10.260 +  \<^descr> @{ML FIRST}~@{text "[tac\<^sub>1, \<dots>, tac\<^sub>n]"} abbreviates @{text
  10.261    "tac\<^sub>1"}~@{ML_op ORELSE}~@{text "\<dots>"}~@{ML_op "ORELSE"}~@{text
  10.262    "tac\<^sub>n"}.  Note that @{ML "FIRST []"} is the same as @{ML no_tac}: it
  10.263    always fails.
  10.264  
  10.265 -  \item @{ML_op "THEN'"} is the lifted version of @{ML_op "THEN"}, for
  10.266 +  \<^descr> @{ML_op "THEN'"} is the lifted version of @{ML_op "THEN"}, for
  10.267    tactics with explicit subgoal addressing.  So @{text
  10.268    "(tac\<^sub>1"}~@{ML_op THEN'}~@{text "tac\<^sub>2) i"} is the same as @{text
  10.269    "(tac\<^sub>1 i"}~@{ML_op THEN}~@{text "tac\<^sub>2 i)"}.
  10.270 @@ -643,7 +643,7 @@
  10.271  
  10.272    \begin{description}
  10.273  
  10.274 -  \item @{ML TRY}~@{text "tac"} applies @{text "tac"} to the goal
  10.275 +  \<^descr> @{ML TRY}~@{text "tac"} applies @{text "tac"} to the goal
  10.276    state and returns the resulting sequence, if non-empty; otherwise it
  10.277    returns the original state.  Thus, it applies @{text "tac"} at most
  10.278    once.
  10.279 @@ -652,7 +652,7 @@
  10.280    applied via functional composition: @{ML "TRY"}~@{ML_op o}~@{text
  10.281    "tac"}.  There is no need for @{verbatim TRY'}.
  10.282  
  10.283 -  \item @{ML REPEAT}~@{text "tac"} applies @{text "tac"} to the goal
  10.284 +  \<^descr> @{ML REPEAT}~@{text "tac"} applies @{text "tac"} to the goal
  10.285    state and, recursively, to each element of the resulting sequence.
  10.286    The resulting sequence consists of those states that make @{text
  10.287    "tac"} fail.  Thus, it applies @{text "tac"} as many times as
  10.288 @@ -660,16 +660,16 @@
  10.289    invocation of @{text "tac"}.  @{ML REPEAT} is more general than @{ML
  10.290    REPEAT_DETERM}, but requires more space.
  10.291  
  10.292 -  \item @{ML REPEAT1}~@{text "tac"} is like @{ML REPEAT}~@{text "tac"}
  10.293 +  \<^descr> @{ML REPEAT1}~@{text "tac"} is like @{ML REPEAT}~@{text "tac"}
  10.294    but it always applies @{text "tac"} at least once, failing if this
  10.295    is impossible.
  10.296  
  10.297 -  \item @{ML REPEAT_DETERM}~@{text "tac"} applies @{text "tac"} to the
  10.298 +  \<^descr> @{ML REPEAT_DETERM}~@{text "tac"} applies @{text "tac"} to the
  10.299    goal state and, recursively, to the head of the resulting sequence.
  10.300    It returns the first state to make @{text "tac"} fail.  It is
  10.301    deterministic, discarding alternative outcomes.
  10.302  
  10.303 -  \item @{ML REPEAT_DETERM_N}~@{text "n tac"} is like @{ML
  10.304 +  \<^descr> @{ML REPEAT_DETERM_N}~@{text "n tac"} is like @{ML
  10.305    REPEAT_DETERM}~@{text "tac"} but the number of repetitions is bound
  10.306    by @{text "n"} (where @{ML "~1"} means @{text "\<infinity>"}).
  10.307  
  10.308 @@ -749,28 +749,28 @@
  10.309  
  10.310    \begin{description}
  10.311  
  10.312 -  \item @{ML ALLGOALS}~@{text "tac"} is equivalent to @{text "tac
  10.313 +  \<^descr> @{ML ALLGOALS}~@{text "tac"} is equivalent to @{text "tac
  10.314    n"}~@{ML_op THEN}~@{text "\<dots>"}~@{ML_op THEN}~@{text "tac 1"}.  It
  10.315    applies the @{text tac} to all the subgoals, counting downwards.
  10.316  
  10.317 -  \item @{ML SOMEGOAL}~@{text "tac"} is equivalent to @{text "tac
  10.318 +  \<^descr> @{ML SOMEGOAL}~@{text "tac"} is equivalent to @{text "tac
  10.319    n"}~@{ML_op ORELSE}~@{text "\<dots>"}~@{ML_op ORELSE}~@{text "tac 1"}.  It
  10.320    applies @{text "tac"} to one subgoal, counting downwards.
  10.321  
  10.322 -  \item @{ML FIRSTGOAL}~@{text "tac"} is equivalent to @{text "tac
  10.323 +  \<^descr> @{ML FIRSTGOAL}~@{text "tac"} is equivalent to @{text "tac
  10.324    1"}~@{ML_op ORELSE}~@{text "\<dots>"}~@{ML_op ORELSE}~@{text "tac n"}.  It
  10.325    applies @{text "tac"} to one subgoal, counting upwards.
  10.326  
  10.327 -  \item @{ML HEADGOAL}~@{text "tac"} is equivalent to @{text "tac 1"}.
  10.328 +  \<^descr> @{ML HEADGOAL}~@{text "tac"} is equivalent to @{text "tac 1"}.
  10.329    It applies @{text "tac"} unconditionally to the first subgoal.
  10.330  
  10.331 -  \item @{ML REPEAT_SOME}~@{text "tac"} applies @{text "tac"} once or
  10.332 +  \<^descr> @{ML REPEAT_SOME}~@{text "tac"} applies @{text "tac"} once or
  10.333    more to a subgoal, counting downwards.
  10.334  
  10.335 -  \item @{ML REPEAT_FIRST}~@{text "tac"} applies @{text "tac"} once or
  10.336 +  \<^descr> @{ML REPEAT_FIRST}~@{text "tac"} applies @{text "tac"} once or
  10.337    more to a subgoal, counting upwards.
  10.338  
  10.339 -  \item @{ML RANGE}~@{text "[tac\<^sub>1, \<dots>, tac\<^sub>k] i"} is equivalent to
  10.340 +  \<^descr> @{ML RANGE}~@{text "[tac\<^sub>1, \<dots>, tac\<^sub>k] i"} is equivalent to
  10.341    @{text "tac\<^sub>k (i + k - 1)"}~@{ML_op THEN}~@{text "\<dots>"}~@{ML_op
  10.342    THEN}~@{text "tac\<^sub>1 i"}.  It applies the given list of tactics to the
  10.343    corresponding range of subgoals, counting downwards.
  10.344 @@ -802,11 +802,11 @@
  10.345  
  10.346    \begin{description}
  10.347  
  10.348 -  \item @{ML FILTER}~@{text "sat tac"} applies @{text "tac"} to the
  10.349 +  \<^descr> @{ML FILTER}~@{text "sat tac"} applies @{text "tac"} to the
  10.350    goal state and returns a sequence consisting of those result goal
  10.351    states that are satisfactory in the sense of @{text "sat"}.
  10.352  
  10.353 -  \item @{ML CHANGED}~@{text "tac"} applies @{text "tac"} to the goal
  10.354 +  \<^descr> @{ML CHANGED}~@{text "tac"} applies @{text "tac"} to the goal
  10.355    state and returns precisely those states that differ from the
  10.356    original state (according to @{ML Thm.eq_thm}).  Thus @{ML
  10.357    CHANGED}~@{text "tac"} always has some effect on the state.
  10.358 @@ -826,17 +826,17 @@
  10.359  
  10.360    \begin{description}
  10.361  
  10.362 -  \item @{ML DEPTH_FIRST}~@{text "sat tac"} returns the goal state if
  10.363 +  \<^descr> @{ML DEPTH_FIRST}~@{text "sat tac"} returns the goal state if
  10.364    @{text "sat"} returns true.  Otherwise it applies @{text "tac"},
  10.365    then recursively searches from each element of the resulting
  10.366    sequence.  The code uses a stack for efficiency, in effect applying
  10.367    @{text "tac"}~@{ML_op THEN}~@{ML DEPTH_FIRST}~@{text "sat tac"} to
  10.368    the state.
  10.369  
  10.370 -  \item @{ML DEPTH_SOLVE}@{text "tac"} uses @{ML DEPTH_FIRST} to
  10.371 +  \<^descr> @{ML DEPTH_SOLVE}@{text "tac"} uses @{ML DEPTH_FIRST} to
  10.372    search for states having no subgoals.
  10.373  
  10.374 -  \item @{ML DEPTH_SOLVE_1}~@{text "tac"} uses @{ML DEPTH_FIRST} to
  10.375 +  \<^descr> @{ML DEPTH_SOLVE_1}~@{text "tac"} uses @{ML DEPTH_FIRST} to
  10.376    search for states having fewer subgoals than the given state.  Thus,
  10.377    it insists upon solving at least one subgoal.
  10.378  
  10.379 @@ -859,11 +859,11 @@
  10.380  
  10.381    \begin{description}
  10.382  
  10.383 -  \item @{ML BREADTH_FIRST}~@{text "sat tac"} uses breadth-first
  10.384 +  \<^descr> @{ML BREADTH_FIRST}~@{text "sat tac"} uses breadth-first
  10.385    search to find states for which @{text "sat"} is true.  For most
  10.386    applications, it is too slow.
  10.387  
  10.388 -  \item @{ML BEST_FIRST}~@{text "(sat, dist) tac"} does a heuristic
  10.389 +  \<^descr> @{ML BEST_FIRST}~@{text "(sat, dist) tac"} does a heuristic
  10.390    search, using @{text "dist"} to estimate the distance from a
  10.391    satisfactory state (in the sense of @{text "sat"}).  It maintains a
  10.392    list of states ordered by distance.  It applies @{text "tac"} to the
  10.393 @@ -875,7 +875,7 @@
  10.394    the size of the state.  The smaller the state, the fewer and simpler
  10.395    subgoals it has.
  10.396  
  10.397 -  \item @{ML THEN_BEST_FIRST}~@{text "tac\<^sub>0 (sat, dist) tac"} is like
  10.398 +  \<^descr> @{ML THEN_BEST_FIRST}~@{text "tac\<^sub>0 (sat, dist) tac"} is like
  10.399    @{ML BEST_FIRST}, except that the priority queue initially contains
  10.400    the result of applying @{text "tac\<^sub>0"} to the goal state.  This
  10.401    tactical permits separate tactics for starting the search and
  10.402 @@ -897,22 +897,22 @@
  10.403  
  10.404    \begin{description}
  10.405  
  10.406 -  \item @{ML COND}~@{text "sat tac\<^sub>1 tac\<^sub>2"} applies @{text "tac\<^sub>1"} to
  10.407 +  \<^descr> @{ML COND}~@{text "sat tac\<^sub>1 tac\<^sub>2"} applies @{text "tac\<^sub>1"} to
  10.408    the goal state if it satisfies predicate @{text "sat"}, and applies
  10.409    @{text "tac\<^sub>2"}.  It is a conditional tactical in that only one of
  10.410    @{text "tac\<^sub>1"} and @{text "tac\<^sub>2"} is applied to a goal state.
  10.411    However, both @{text "tac\<^sub>1"} and @{text "tac\<^sub>2"} are evaluated
  10.412    because ML uses eager evaluation.
  10.413  
  10.414 -  \item @{ML IF_UNSOLVED}~@{text "tac"} applies @{text "tac"} to the
  10.415 +  \<^descr> @{ML IF_UNSOLVED}~@{text "tac"} applies @{text "tac"} to the
  10.416    goal state if it has any subgoals, and simply returns the goal state
  10.417    otherwise.  Many common tactics, such as @{ML resolve_tac}, fail if
  10.418    applied to a goal state that has no subgoals.
  10.419  
  10.420 -  \item @{ML SOLVE}~@{text "tac"} applies @{text "tac"} to the goal
  10.421 +  \<^descr> @{ML SOLVE}~@{text "tac"} applies @{text "tac"} to the goal
  10.422    state and then fails iff there are subgoals left.
  10.423  
  10.424 -  \item @{ML DETERM}~@{text "tac"} applies @{text "tac"} to the goal
  10.425 +  \<^descr> @{ML DETERM}~@{text "tac"} applies @{text "tac"} to the goal
  10.426    state and returns the head of the resulting sequence.  @{ML DETERM}
  10.427    limits the search space by making its argument deterministic.
  10.428  
  10.429 @@ -932,19 +932,19 @@
  10.430  
  10.431    \begin{description}
  10.432  
  10.433 -  \item @{ML has_fewer_prems}~@{text "n thm"} reports whether @{text
  10.434 +  \<^descr> @{ML has_fewer_prems}~@{text "n thm"} reports whether @{text
  10.435    "thm"} has fewer than @{text "n"} premises.
  10.436  
  10.437 -  \item @{ML Thm.eq_thm}~@{text "(thm\<^sub>1, thm\<^sub>2)"} reports whether @{text
  10.438 +  \<^descr> @{ML Thm.eq_thm}~@{text "(thm\<^sub>1, thm\<^sub>2)"} reports whether @{text
  10.439    "thm\<^sub>1"} and @{text "thm\<^sub>2"} are equal.  Both theorems must have the
  10.440    same conclusions, the same set of hypotheses, and the same set of sort
  10.441    hypotheses.  Names of bound variables are ignored as usual.
  10.442  
  10.443 -  \item @{ML Thm.eq_thm_prop}~@{text "(thm\<^sub>1, thm\<^sub>2)"} reports whether
  10.444 +  \<^descr> @{ML Thm.eq_thm_prop}~@{text "(thm\<^sub>1, thm\<^sub>2)"} reports whether
  10.445    the propositions of @{text "thm\<^sub>1"} and @{text "thm\<^sub>2"} are equal.
  10.446    Names of bound variables are ignored.
  10.447  
  10.448 -  \item @{ML size_of_thm}~@{text "thm"} computes the size of @{text
  10.449 +  \<^descr> @{ML size_of_thm}~@{text "thm"} computes the size of @{text
  10.450    "thm"}, namely the number of variables, constants and abstractions
  10.451    in its conclusion.  It may serve as a distance function for
  10.452    @{ML BEST_FIRST}.
    11.1 --- a/src/Doc/Isar_Ref/Document_Preparation.thy	Wed Oct 14 15:06:42 2015 +0200
    11.2 +++ b/src/Doc/Isar_Ref/Document_Preparation.thy	Wed Oct 14 15:10:32 2015 +0200
    11.3 @@ -51,19 +51,19 @@
    11.4  
    11.5    \begin{description}
    11.6  
    11.7 -  \item @{command chapter}, @{command section}, @{command subsection}, and
    11.8 +  \<^descr> @{command chapter}, @{command section}, @{command subsection}, and
    11.9    @{command subsubsection} mark chapter and section headings within the
   11.10    theory source; this works in any context, even before the initial
   11.11    @{command theory} command. The corresponding {\LaTeX} macros are
   11.12    @{verbatim \<open>\isamarkupchapter\<close>}, @{verbatim \<open>\isamarkupsection\<close>},
   11.13    @{verbatim \<open>\isamarkupsubsection\<close>}, @{verbatim \<open>\isamarkupsubsubsection\<close>}.
   11.14  
   11.15 -  \item @{command text} and @{command txt} specify paragraphs of plain text.
   11.16 +  \<^descr> @{command text} and @{command txt} specify paragraphs of plain text.
   11.17    This corresponds to a {\LaTeX} environment @{verbatim
   11.18    \<open>\begin{isamarkuptext}\<close>} @{text "\<dots>"} @{verbatim \<open>\end{isamarkuptext}\<close>}
   11.19    etc.
   11.20  
   11.21 -  \item @{command text_raw} inserts {\LaTeX} source directly into the
   11.22 +  \<^descr> @{command text_raw} inserts {\LaTeX} source directly into the
   11.23    output, without additional markup. Thus the full range of document
   11.24    manipulations becomes available, at the risk of messing up document
   11.25    output.
   11.26 @@ -189,55 +189,55 @@
   11.27  
   11.28    \begin{description}
   11.29  
   11.30 -  \item @{command "print_antiquotations"} prints all document antiquotations
   11.31 +  \<^descr> @{command "print_antiquotations"} prints all document antiquotations
   11.32    that are defined in the current context; the ``@{text "!"}'' option
   11.33    indicates extra verbosity.
   11.34  
   11.35 -  \item @{text "@{theory A}"} prints the name @{text "A"}, which is
   11.36 +  \<^descr> @{text "@{theory A}"} prints the name @{text "A"}, which is
   11.37    guaranteed to refer to a valid ancestor theory in the current
   11.38    context.
   11.39  
   11.40 -  \item @{text "@{thm a\<^sub>1 \<dots> a\<^sub>n}"} prints theorems @{text "a\<^sub>1 \<dots> a\<^sub>n"}.
   11.41 +  \<^descr> @{text "@{thm a\<^sub>1 \<dots> a\<^sub>n}"} prints theorems @{text "a\<^sub>1 \<dots> a\<^sub>n"}.
   11.42    Full fact expressions are allowed here, including attributes
   11.43    (\secref{sec:syn-att}).
   11.44  
   11.45 -  \item @{text "@{prop \<phi>}"} prints a well-typed proposition @{text
   11.46 +  \<^descr> @{text "@{prop \<phi>}"} prints a well-typed proposition @{text
   11.47    "\<phi>"}.
   11.48  
   11.49 -  \item @{text "@{lemma \<phi> by m}"} proves a well-typed proposition
   11.50 +  \<^descr> @{text "@{lemma \<phi> by m}"} proves a well-typed proposition
   11.51    @{text "\<phi>"} by method @{text m} and prints the original @{text "\<phi>"}.
   11.52  
   11.53 -  \item @{text "@{term t}"} prints a well-typed term @{text "t"}.
   11.54 +  \<^descr> @{text "@{term t}"} prints a well-typed term @{text "t"}.
   11.55    
   11.56 -  \item @{text "@{value t}"} evaluates a term @{text "t"} and prints
   11.57 +  \<^descr> @{text "@{value t}"} evaluates a term @{text "t"} and prints
   11.58    its result, see also @{command_ref (HOL) value}.
   11.59  
   11.60 -  \item @{text "@{term_type t}"} prints a well-typed term @{text "t"}
   11.61 +  \<^descr> @{text "@{term_type t}"} prints a well-typed term @{text "t"}
   11.62    annotated with its type.
   11.63  
   11.64 -  \item @{text "@{typeof t}"} prints the type of a well-typed term
   11.65 +  \<^descr> @{text "@{typeof t}"} prints the type of a well-typed term
   11.66    @{text "t"}.
   11.67  
   11.68 -  \item @{text "@{const c}"} prints a logical or syntactic constant
   11.69 +  \<^descr> @{text "@{const c}"} prints a logical or syntactic constant
   11.70    @{text "c"}.
   11.71    
   11.72 -  \item @{text "@{abbrev c x\<^sub>1 \<dots> x\<^sub>n}"} prints a constant abbreviation
   11.73 +  \<^descr> @{text "@{abbrev c x\<^sub>1 \<dots> x\<^sub>n}"} prints a constant abbreviation
   11.74    @{text "c x\<^sub>1 \<dots> x\<^sub>n \<equiv> rhs"} as defined in the current context.
   11.75  
   11.76 -  \item @{text "@{typ \<tau>}"} prints a well-formed type @{text "\<tau>"}.
   11.77 +  \<^descr> @{text "@{typ \<tau>}"} prints a well-formed type @{text "\<tau>"}.
   11.78  
   11.79 -  \item @{text "@{type \<kappa>}"} prints a (logical or syntactic) type
   11.80 +  \<^descr> @{text "@{type \<kappa>}"} prints a (logical or syntactic) type
   11.81      constructor @{text "\<kappa>"}.
   11.82  
   11.83 -  \item @{text "@{class c}"} prints a class @{text c}.
   11.84 +  \<^descr> @{text "@{class c}"} prints a class @{text c}.
   11.85  
   11.86 -  \item @{text "@{text s}"} prints uninterpreted source text @{text
   11.87 +  \<^descr> @{text "@{text s}"} prints uninterpreted source text @{text
   11.88    s}.  This is particularly useful to print portions of text according
   11.89    to the Isabelle document style, without demanding well-formedness,
   11.90    e.g.\ small pieces of terms that should not be parsed or
   11.91    type-checked yet.
   11.92  
   11.93 -  \item @{text "@{goals}"} prints the current \emph{dynamic} goal
   11.94 +  \<^descr> @{text "@{goals}"} prints the current \emph{dynamic} goal
   11.95    state.  This is mainly for support of tactic-emulation scripts
   11.96    within Isar.  Presentation of goal states does not conform to the
   11.97    idea of human-readable proof documents!
   11.98 @@ -246,38 +246,38 @@
   11.99    the reasoning via proper Isar proof commands, instead of peeking at
  11.100    the internal machine configuration.
  11.101    
  11.102 -  \item @{text "@{subgoals}"} is similar to @{text "@{goals}"}, but
  11.103 +  \<^descr> @{text "@{subgoals}"} is similar to @{text "@{goals}"}, but
  11.104    does not print the main goal.
  11.105    
  11.106 -  \item @{text "@{prf a\<^sub>1 \<dots> a\<^sub>n}"} prints the (compact) proof terms
  11.107 +  \<^descr> @{text "@{prf a\<^sub>1 \<dots> a\<^sub>n}"} prints the (compact) proof terms
  11.108    corresponding to the theorems @{text "a\<^sub>1 \<dots> a\<^sub>n"}. Note that this
  11.109    requires proof terms to be switched on for the current logic
  11.110    session.
  11.111    
  11.112 -  \item @{text "@{full_prf a\<^sub>1 \<dots> a\<^sub>n}"} is like @{text "@{prf a\<^sub>1 \<dots>
  11.113 +  \<^descr> @{text "@{full_prf a\<^sub>1 \<dots> a\<^sub>n}"} is like @{text "@{prf a\<^sub>1 \<dots>
  11.114    a\<^sub>n}"}, but prints the full proof terms, i.e.\ also displays
  11.115    information omitted in the compact proof term, which is denoted by
  11.116    ``@{text _}'' placeholders there.
  11.117    
  11.118 -  \item @{text "@{ML s}"}, @{text "@{ML_op s}"}, @{text "@{ML_type
  11.119 +  \<^descr> @{text "@{ML s}"}, @{text "@{ML_op s}"}, @{text "@{ML_type
  11.120    s}"}, @{text "@{ML_structure s}"}, and @{text "@{ML_functor s}"}
  11.121    check text @{text s} as ML value, infix operator, type, structure,
  11.122    and functor respectively.  The source is printed verbatim.
  11.123  
  11.124 -  \item @{text "@{verbatim s}"} prints uninterpreted source text literally
  11.125 +  \<^descr> @{text "@{verbatim s}"} prints uninterpreted source text literally
  11.126    as ASCII characters, using some type-writer font style.
  11.127  
  11.128 -  \item @{text "@{file path}"} checks that @{text "path"} refers to a
  11.129 +  \<^descr> @{text "@{file path}"} checks that @{text "path"} refers to a
  11.130    file (or directory) and prints it verbatim.
  11.131  
  11.132 -  \item @{text "@{file_unchecked path}"} is like @{text "@{file
  11.133 +  \<^descr> @{text "@{file_unchecked path}"} is like @{text "@{file
  11.134    path}"}, but does not check the existence of the @{text "path"}
  11.135    within the file-system.
  11.136  
  11.137 -  \item @{text "@{url name}"} produces markup for the given URL, which
  11.138 +  \<^descr> @{text "@{url name}"} produces markup for the given URL, which
  11.139    results in an active hyperlink within the text.
  11.140  
  11.141 -  \item @{text "@{cite name}"} produces a citation @{verbatim
  11.142 +  \<^descr> @{text "@{cite name}"} produces a citation @{verbatim
  11.143    \<open>\cite{name}\<close>} in {\LaTeX}, where the name refers to some Bib{\TeX}
  11.144    database entry.
  11.145  
  11.146 @@ -305,17 +305,17 @@
  11.147  
  11.148    \begin{description}
  11.149    
  11.150 -  \item @{text lhs} extracts the first argument of any application
  11.151 +  \<^descr> @{text lhs} extracts the first argument of any application
  11.152    form with at least two arguments --- typically meta-level or
  11.153    object-level equality, or any other binary relation.
  11.154    
  11.155 -  \item @{text rhs} is like @{text lhs}, but extracts the second
  11.156 +  \<^descr> @{text rhs} is like @{text lhs}, but extracts the second
  11.157    argument.
  11.158    
  11.159 -  \item @{text "concl"} extracts the conclusion @{text C} from a rule
  11.160 +  \<^descr> @{text "concl"} extracts the conclusion @{text C} from a rule
  11.161    in Horn-clause normal form @{text "A\<^sub>1 \<Longrightarrow> \<dots> A\<^sub>n \<Longrightarrow> C"}.
  11.162    
  11.163 -  \item @{text "prem"} @{text n} extract premise number
  11.164 +  \<^descr> @{text "prem"} @{text n} extract premise number
  11.165    @{text "n"} from from a rule in Horn-clause
  11.166    normal form @{text "A\<^sub>1 \<Longrightarrow> \<dots> A\<^sub>n \<Longrightarrow> C"}
  11.167  
  11.168 @@ -331,34 +331,34 @@
  11.169  
  11.170    \begin{description}
  11.171  
  11.172 -  \item @{antiquotation_option_def show_types}~@{text "= bool"} and
  11.173 +  \<^descr> @{antiquotation_option_def show_types}~@{text "= bool"} and
  11.174    @{antiquotation_option_def show_sorts}~@{text "= bool"} control
  11.175    printing of explicit type and sort constraints.
  11.176  
  11.177 -  \item @{antiquotation_option_def show_structs}~@{text "= bool"}
  11.178 +  \<^descr> @{antiquotation_option_def show_structs}~@{text "= bool"}
  11.179    controls printing of implicit structures.
  11.180  
  11.181 -  \item @{antiquotation_option_def show_abbrevs}~@{text "= bool"}
  11.182 +  \<^descr> @{antiquotation_option_def show_abbrevs}~@{text "= bool"}
  11.183    controls folding of abbreviations.
  11.184  
  11.185 -  \item @{antiquotation_option_def names_long}~@{text "= bool"} forces
  11.186 +  \<^descr> @{antiquotation_option_def names_long}~@{text "= bool"} forces
  11.187    names of types and constants etc.\ to be printed in their fully
  11.188    qualified internal form.
  11.189  
  11.190 -  \item @{antiquotation_option_def names_short}~@{text "= bool"}
  11.191 +  \<^descr> @{antiquotation_option_def names_short}~@{text "= bool"}
  11.192    forces names of types and constants etc.\ to be printed unqualified.
  11.193    Note that internalizing the output again in the current context may
  11.194    well yield a different result.
  11.195  
  11.196 -  \item @{antiquotation_option_def names_unique}~@{text "= bool"}
  11.197 +  \<^descr> @{antiquotation_option_def names_unique}~@{text "= bool"}
  11.198    determines whether the printed version of qualified names should be
  11.199    made sufficiently long to avoid overlap with names declared further
  11.200    back.  Set to @{text false} for more concise output.
  11.201  
  11.202 -  \item @{antiquotation_option_def eta_contract}~@{text "= bool"}
  11.203 +  \<^descr> @{antiquotation_option_def eta_contract}~@{text "= bool"}
  11.204    prints terms in @{text \<eta>}-contracted form.
  11.205  
  11.206 -  \item @{antiquotation_option_def display}~@{text "= bool"} indicates
  11.207 +  \<^descr> @{antiquotation_option_def display}~@{text "= bool"} indicates
  11.208    if the text is to be output as multi-line ``display material'',
  11.209    rather than a small piece of text without line breaks (which is the
  11.210    default).
  11.211 @@ -366,26 +366,26 @@
  11.212    In this mode the embedded entities are printed in the same style as
  11.213    the main theory text.
  11.214  
  11.215 -  \item @{antiquotation_option_def break}~@{text "= bool"} controls
  11.216 +  \<^descr> @{antiquotation_option_def break}~@{text "= bool"} controls
  11.217    line breaks in non-display material.
  11.218  
  11.219 -  \item @{antiquotation_option_def quotes}~@{text "= bool"} indicates
  11.220 +  \<^descr> @{antiquotation_option_def quotes}~@{text "= bool"} indicates
  11.221    if the output should be enclosed in double quotes.
  11.222  
  11.223 -  \item @{antiquotation_option_def mode}~@{text "= name"} adds @{text
  11.224 +  \<^descr> @{antiquotation_option_def mode}~@{text "= name"} adds @{text
  11.225    name} to the print mode to be used for presentation.  Note that the
  11.226    standard setup for {\LaTeX} output is already present by default,
  11.227    including the modes @{text latex} and @{text xsymbols}.
  11.228  
  11.229 -  \item @{antiquotation_option_def margin}~@{text "= nat"} and
  11.230 +  \<^descr> @{antiquotation_option_def margin}~@{text "= nat"} and
  11.231    @{antiquotation_option_def indent}~@{text "= nat"} change the margin
  11.232    or indentation for pretty printing of display material.
  11.233  
  11.234 -  \item @{antiquotation_option_def goals_limit}~@{text "= nat"}
  11.235 +  \<^descr> @{antiquotation_option_def goals_limit}~@{text "= nat"}
  11.236    determines the maximum number of subgoals to be printed (for goal-based
  11.237    antiquotation).
  11.238  
  11.239 -  \item @{antiquotation_option_def source}~@{text "= bool"} prints the
  11.240 +  \<^descr> @{antiquotation_option_def source}~@{text "= bool"} prints the
  11.241    original source text of the antiquotation arguments, rather than its
  11.242    internal representation.  Note that formal checking of
  11.243    @{antiquotation "thm"}, @{antiquotation "term"}, etc. is still
  11.244 @@ -592,7 +592,7 @@
  11.245  
  11.246    \begin{description}
  11.247  
  11.248 -  \item @{command "display_drafts"}~@{text paths} performs simple output of a
  11.249 +  \<^descr> @{command "display_drafts"}~@{text paths} performs simple output of a
  11.250    given list of raw source files. Only those symbols that do not require
  11.251    additional {\LaTeX} packages are displayed properly, everything else is left
  11.252    verbatim.
    12.1 --- a/src/Doc/Isar_Ref/Generic.thy	Wed Oct 14 15:06:42 2015 +0200
    12.2 +++ b/src/Doc/Isar_Ref/Generic.thy	Wed Oct 14 15:10:32 2015 +0200
    12.3 @@ -40,11 +40,11 @@
    12.4  
    12.5    \begin{description}
    12.6    
    12.7 -  \item @{command "print_options"} prints the available configuration
    12.8 +  \<^descr> @{command "print_options"} prints the available configuration
    12.9    options, with names, types, and current values; the ``@{text "!"}'' option
   12.10    indicates extra verbosity.
   12.11    
   12.12 -  \item @{text "name = value"} as an attribute expression modifies the
   12.13 +  \<^descr> @{text "name = value"} as an attribute expression modifies the
   12.14    named option, with the syntax of the value depending on the option's
   12.15    type.  For @{ML_type bool} the default value is @{text true}.  Any
   12.16    attempt to change a global option in a local context is ignored.
   12.17 @@ -85,16 +85,16 @@
   12.18  
   12.19    \begin{description}
   12.20    
   12.21 -  \item @{method unfold}~@{text "a\<^sub>1 \<dots> a\<^sub>n"} and @{method fold}~@{text
   12.22 +  \<^descr> @{method unfold}~@{text "a\<^sub>1 \<dots> a\<^sub>n"} and @{method fold}~@{text
   12.23    "a\<^sub>1 \<dots> a\<^sub>n"} expand (or fold back) the given definitions throughout
   12.24    all goals; any chained facts provided are inserted into the goal and
   12.25    subject to rewriting as well.
   12.26  
   12.27 -  \item @{method insert}~@{text "a\<^sub>1 \<dots> a\<^sub>n"} inserts theorems as facts
   12.28 +  \<^descr> @{method insert}~@{text "a\<^sub>1 \<dots> a\<^sub>n"} inserts theorems as facts
   12.29    into all goals of the proof state.  Note that current facts
   12.30    indicated for forward chaining are ignored.
   12.31  
   12.32 -  \item @{method erule}~@{text "a\<^sub>1 \<dots> a\<^sub>n"}, @{method
   12.33 +  \<^descr> @{method erule}~@{text "a\<^sub>1 \<dots> a\<^sub>n"}, @{method
   12.34    drule}~@{text "a\<^sub>1 \<dots> a\<^sub>n"}, and @{method frule}~@{text
   12.35    "a\<^sub>1 \<dots> a\<^sub>n"} are similar to the basic @{method rule}
   12.36    method (see \secref{sec:pure-meth-att}), but apply rules by
   12.37 @@ -111,21 +111,21 @@
   12.38    the plain @{method rule} method, with forward chaining of current
   12.39    facts.
   12.40  
   12.41 -  \item @{method intro} and @{method elim} repeatedly refine some goal
   12.42 +  \<^descr> @{method intro} and @{method elim} repeatedly refine some goal
   12.43    by intro- or elim-resolution, after having inserted any chained
   12.44    facts.  Exactly the rules given as arguments are taken into account;
   12.45    this allows fine-tuned decomposition of a proof problem, in contrast
   12.46    to common automated tools.
   12.47  
   12.48 -  \item @{method fail} yields an empty result sequence; it is the
   12.49 +  \<^descr> @{method fail} yields an empty result sequence; it is the
   12.50    identity of the ``@{text "|"}'' method combinator (cf.\
   12.51    \secref{sec:proof-meth}).
   12.52  
   12.53 -  \item @{method succeed} yields a single (unchanged) result; it is
   12.54 +  \<^descr> @{method succeed} yields a single (unchanged) result; it is
   12.55    the identity of the ``@{text ","}'' method combinator (cf.\
   12.56    \secref{sec:proof-meth}).
   12.57  
   12.58 -  \item @{method sleep}~@{text s} succeeds after a real-time delay of @{text
   12.59 +  \<^descr> @{method sleep}~@{text s} succeeds after a real-time delay of @{text
   12.60    s} seconds. This is occasionally useful for demonstration and testing
   12.61    purposes.
   12.62  
   12.63 @@ -157,37 +157,37 @@
   12.64  
   12.65    \begin{description}
   12.66  
   12.67 -  \item @{attribute tagged}~@{text "name value"} and @{attribute
   12.68 +  \<^descr> @{attribute tagged}~@{text "name value"} and @{attribute
   12.69    untagged}~@{text name} add and remove \emph{tags} of some theorem.
   12.70    Tags may be any list of string pairs that serve as formal comment.
   12.71    The first string is considered the tag name, the second its value.
   12.72    Note that @{attribute untagged} removes any tags of the same name.
   12.73  
   12.74 -  \item @{attribute THEN}~@{text a} composes rules by resolution; it
   12.75 +  \<^descr> @{attribute THEN}~@{text a} composes rules by resolution; it
   12.76    resolves with the first premise of @{text a} (an alternative
   12.77    position may be also specified).  See also @{ML_op "RS"} in
   12.78    @{cite "isabelle-implementation"}.
   12.79    
   12.80 -  \item @{attribute unfolded}~@{text "a\<^sub>1 \<dots> a\<^sub>n"} and @{attribute
   12.81 +  \<^descr> @{attribute unfolded}~@{text "a\<^sub>1 \<dots> a\<^sub>n"} and @{attribute
   12.82    folded}~@{text "a\<^sub>1 \<dots> a\<^sub>n"} expand and fold back again the given
   12.83    definitions throughout a rule.
   12.84  
   12.85 -  \item @{attribute abs_def} turns an equation of the form @{prop "f x
   12.86 +  \<^descr> @{attribute abs_def} turns an equation of the form @{prop "f x
   12.87    y \<equiv> t"} into @{prop "f \<equiv> \<lambda>x y. t"}, which ensures that @{method
   12.88    simp} or @{method unfold} steps always expand it.  This also works
   12.89    for object-logic equality.
   12.90  
   12.91 -  \item @{attribute rotated}~@{text n} rotate the premises of a
   12.92 +  \<^descr> @{attribute rotated}~@{text n} rotate the premises of a
   12.93    theorem by @{text n} (default 1).
   12.94  
   12.95 -  \item @{attribute (Pure) elim_format} turns a destruction rule into
   12.96 +  \<^descr> @{attribute (Pure) elim_format} turns a destruction rule into
   12.97    elimination rule format, by resolving with the rule @{prop "PROP A \<Longrightarrow>
   12.98    (PROP A \<Longrightarrow> PROP B) \<Longrightarrow> PROP B"}.
   12.99    
  12.100    Note that the Classical Reasoner (\secref{sec:classical}) provides
  12.101    its own version of this operation.
  12.102  
  12.103 -  \item @{attribute no_vars} replaces schematic variables by free
  12.104 +  \<^descr> @{attribute no_vars} replaces schematic variables by free
  12.105    ones; this is mainly for tuning output of pretty printed theorems.
  12.106  
  12.107    \end{description}
  12.108 @@ -218,14 +218,14 @@
  12.109  
  12.110    \begin{description}
  12.111  
  12.112 -  \item @{method subst}~@{text eq} performs a single substitution step
  12.113 +  \<^descr> @{method subst}~@{text eq} performs a single substitution step
  12.114    using rule @{text eq}, which may be either a meta or object
  12.115    equality.
  12.116  
  12.117 -  \item @{method subst}~@{text "(asm) eq"} substitutes in an
  12.118 +  \<^descr> @{method subst}~@{text "(asm) eq"} substitutes in an
  12.119    assumption.
  12.120  
  12.121 -  \item @{method subst}~@{text "(i \<dots> j) eq"} performs several
  12.122 +  \<^descr> @{method subst}~@{text "(i \<dots> j) eq"} performs several
  12.123    substitutions in the conclusion. The numbers @{text i} to @{text j}
  12.124    indicate the positions to substitute at.  Positions are ordered from
  12.125    the top of the term tree moving down from left to right. For
  12.126 @@ -238,18 +238,18 @@
  12.127    assume all substitutions are performed simultaneously.  Otherwise
  12.128    the behaviour of @{text subst} is not specified.
  12.129  
  12.130 -  \item @{method subst}~@{text "(asm) (i \<dots> j) eq"} performs the
  12.131 +  \<^descr> @{method subst}~@{text "(asm) (i \<dots> j) eq"} performs the
  12.132    substitutions in the assumptions. The positions refer to the
  12.133    assumptions in order from left to right.  For example, given in a
  12.134    goal of the form @{text "P (a + b) \<Longrightarrow> P (c + d) \<Longrightarrow> \<dots>"}, position 1 of
  12.135    commutativity of @{text "+"} is the subterm @{text "a + b"} and
  12.136    position 2 is the subterm @{text "c + d"}.
  12.137  
  12.138 -  \item @{method hypsubst} performs substitution using some
  12.139 +  \<^descr> @{method hypsubst} performs substitution using some
  12.140    assumption; this only works for equations of the form @{text "x =
  12.141    t"} where @{text x} is a free or bound variable.
  12.142  
  12.143 -  \item @{method split}~@{text "a\<^sub>1 \<dots> a\<^sub>n"} performs single-step case
  12.144 +  \<^descr> @{method split}~@{text "a\<^sub>1 \<dots> a\<^sub>n"} performs single-step case
  12.145    splitting using the given rules.  Splitting is performed in the
  12.146    conclusion or some assumption of the subgoal, depending of the
  12.147    structure of the rule.
  12.148 @@ -307,7 +307,7 @@
  12.149  
  12.150    \begin{description}
  12.151  
  12.152 -  \item @{method simp} invokes the Simplifier on the first subgoal,
  12.153 +  \<^descr> @{method simp} invokes the Simplifier on the first subgoal,
  12.154    after inserting chained facts as additional goal premises; further
  12.155    rule declarations may be included via @{text "(simp add: facts)"}.
  12.156    The proof method fails if the subgoal remains unchanged after
  12.157 @@ -348,7 +348,7 @@
  12.158    congruence rules (see also \secref{sec:simp-rules}); the default is
  12.159    to add.
  12.160  
  12.161 -  \item @{method simp_all} is similar to @{method simp}, but acts on
  12.162 +  \<^descr> @{method simp_all} is similar to @{method simp}, but acts on
  12.163    all goals, working backwards from the last to the first one as usual
  12.164    in Isabelle.\footnote{The order is irrelevant for goals without
  12.165    schematic variables, so simplification might actually be performed
  12.166 @@ -361,7 +361,7 @@
  12.167    The proof method fails if all subgoals remain unchanged after
  12.168    simplification.
  12.169  
  12.170 -  \item @{attribute simp_depth_limit} limits the number of recursive
  12.171 +  \<^descr> @{attribute simp_depth_limit} limits the number of recursive
  12.172    invocations of the Simplifier during conditional rewriting.
  12.173  
  12.174    \end{description}
  12.175 @@ -515,7 +515,7 @@
  12.176  
  12.177    \begin{description}
  12.178  
  12.179 -  \item @{attribute simp} declares rewrite rules, by adding or
  12.180 +  \<^descr> @{attribute simp} declares rewrite rules, by adding or
  12.181    deleting them from the simpset within the theory or proof context.
  12.182    Rewrite rules are theorems expressing some form of equality, for
  12.183    example:
  12.184 @@ -576,9 +576,9 @@
  12.185  
  12.186    \end{enumerate}
  12.187  
  12.188 -  \item @{attribute split} declares case split rules.
  12.189 +  \<^descr> @{attribute split} declares case split rules.
  12.190  
  12.191 -  \item @{attribute cong} declares congruence rules to the Simplifier
  12.192 +  \<^descr> @{attribute cong} declares congruence rules to the Simplifier
  12.193    context.
  12.194  
  12.195    Congruence rules are equalities of the form @{text [display]
  12.196 @@ -619,7 +619,7 @@
  12.197    This can make simplification much faster, but may require an extra
  12.198    case split over the condition @{text "?q"} to prove the goal.
  12.199  
  12.200 -  \item @{command "print_simpset"} prints the collection of rules declared
  12.201 +  \<^descr> @{command "print_simpset"} prints the collection of rules declared
  12.202    to the Simplifier, which is also known as ``simpset'' internally; the
  12.203    ``@{text "!"}'' option indicates extra verbosity.
  12.204  
  12.205 @@ -796,19 +796,19 @@
  12.206  
  12.207    \begin{description}
  12.208  
  12.209 -  \item @{attribute simp_trace} makes the Simplifier output internal
  12.210 +  \<^descr> @{attribute simp_trace} makes the Simplifier output internal
  12.211    operations.  This includes rewrite steps, but also bookkeeping like
  12.212    modifications of the simpset.
  12.213  
  12.214 -  \item @{attribute simp_trace_depth_limit} limits the effect of
  12.215 +  \<^descr> @{attribute simp_trace_depth_limit} limits the effect of
  12.216    @{attribute simp_trace} to the given depth of recursive Simplifier
  12.217    invocations (when solving conditions of rewrite rules).
  12.218  
  12.219 -  \item @{attribute simp_debug} makes the Simplifier output some extra
  12.220 +  \<^descr> @{attribute simp_debug} makes the Simplifier output some extra
  12.221    information about internal operations.  This includes any attempted
  12.222    invocation of simplification procedures.
  12.223  
  12.224 -  \item @{attribute simp_trace_new} controls Simplifier tracing within
  12.225 +  \<^descr> @{attribute simp_trace_new} controls Simplifier tracing within
  12.226    Isabelle/PIDE applications, notably Isabelle/jEdit @{cite "isabelle-jedit"}.
  12.227    This provides a hierarchical representation of the rewriting steps
  12.228    performed by the Simplifier.
  12.229 @@ -820,7 +820,7 @@
  12.230    Interactive mode interrupts the normal flow of the Simplifier and defers
  12.231    the decision how to continue to the user via some GUI dialog.
  12.232  
  12.233 -  \item @{attribute simp_break} declares term or theorem breakpoints for
  12.234 +  \<^descr> @{attribute simp_break} declares term or theorem breakpoints for
  12.235    @{attribute simp_trace_new} as described above. Term breakpoints are
  12.236    patterns which are checked for matches on the redex of a rule application.
  12.237    Theorem breakpoints trigger when the corresponding theorem is applied in a
  12.238 @@ -868,7 +868,7 @@
  12.239  
  12.240    \begin{description}
  12.241  
  12.242 -  \item @{command "simproc_setup"} defines a named simplification
  12.243 +  \<^descr> @{command "simproc_setup"} defines a named simplification
  12.244    procedure that is invoked by the Simplifier whenever any of the
  12.245    given term patterns match the current redex.  The implementation,
  12.246    which is provided as ML source text, needs to be of type @{ML_type
  12.247 @@ -887,7 +887,7 @@
  12.248    Morphisms and identifiers are only relevant for simprocs that are
  12.249    defined within a local target context, e.g.\ in a locale.
  12.250  
  12.251 -  \item @{text "simproc add: name"} and @{text "simproc del: name"}
  12.252 +  \<^descr> @{text "simproc add: name"} and @{text "simproc del: name"}
  12.253    add or delete named simprocs to the current Simplifier context.  The
  12.254    default is to add a simproc.  Note that @{command "simproc_setup"}
  12.255    already adds the new simproc to the subsequent context.
  12.256 @@ -946,11 +946,11 @@
  12.257  
  12.258    \begin{description}
  12.259  
  12.260 -  \item @{ML Simplifier.set_subgoaler}~@{text "tac ctxt"} sets the
  12.261 +  \<^descr> @{ML Simplifier.set_subgoaler}~@{text "tac ctxt"} sets the
  12.262    subgoaler of the context to @{text "tac"}.  The tactic will
  12.263    be applied to the context of the running Simplifier instance.
  12.264  
  12.265 -  \item @{ML Simplifier.prems_of}~@{text "ctxt"} retrieves the current
  12.266 +  \<^descr> @{ML Simplifier.prems_of}~@{text "ctxt"} retrieves the current
  12.267    set of premises from the context.  This may be non-empty only if
  12.268    the Simplifier has been told to utilize local assumptions in the
  12.269    first place (cf.\ the options in \secref{sec:simp-meth}).
  12.270 @@ -1016,21 +1016,21 @@
  12.271  
  12.272    \begin{description}
  12.273  
  12.274 -  \item @{ML Simplifier.mk_solver}~@{text "name tac"} turns @{text
  12.275 +  \<^descr> @{ML Simplifier.mk_solver}~@{text "name tac"} turns @{text
  12.276    "tac"} into a solver; the @{text "name"} is only attached as a
  12.277    comment and has no further significance.
  12.278  
  12.279 -  \item @{text "ctxt setSSolver solver"} installs @{text "solver"} as
  12.280 +  \<^descr> @{text "ctxt setSSolver solver"} installs @{text "solver"} as
  12.281    the safe solver of @{text "ctxt"}.
  12.282  
  12.283 -  \item @{text "ctxt addSSolver solver"} adds @{text "solver"} as an
  12.284 +  \<^descr> @{text "ctxt addSSolver solver"} adds @{text "solver"} as an
  12.285    additional safe solver; it will be tried after the solvers which had
  12.286    already been present in @{text "ctxt"}.
  12.287  
  12.288 -  \item @{text "ctxt setSolver solver"} installs @{text "solver"} as the
  12.289 +  \<^descr> @{text "ctxt setSolver solver"} installs @{text "solver"} as the
  12.290    unsafe solver of @{text "ctxt"}.
  12.291  
  12.292 -  \item @{text "ctxt addSolver solver"} adds @{text "solver"} as an
  12.293 +  \<^descr> @{text "ctxt addSolver solver"} adds @{text "solver"} as an
  12.294    additional unsafe solver; it will be tried after the solvers which
  12.295    had already been present in @{text "ctxt"}.
  12.296  
  12.297 @@ -1102,22 +1102,22 @@
  12.298  
  12.299    \begin{description}
  12.300  
  12.301 -  \item @{text "ctxt setloop tac"} installs @{text "tac"} as the only
  12.302 +  \<^descr> @{text "ctxt setloop tac"} installs @{text "tac"} as the only
  12.303    looper tactic of @{text "ctxt"}.
  12.304  
  12.305 -  \item @{text "ctxt addloop (name, tac)"} adds @{text "tac"} as an
  12.306 +  \<^descr> @{text "ctxt addloop (name, tac)"} adds @{text "tac"} as an
  12.307    additional looper tactic with name @{text "name"}, which is
  12.308    significant for managing the collection of loopers.  The tactic will
  12.309    be tried after the looper tactics that had already been present in
  12.310    @{text "ctxt"}.
  12.311  
  12.312 -  \item @{text "ctxt delloop name"} deletes the looper tactic that was
  12.313 +  \<^descr> @{text "ctxt delloop name"} deletes the looper tactic that was
  12.314    associated with @{text "name"} from @{text "ctxt"}.
  12.315  
  12.316 -  \item @{ML Splitter.add_split}~@{text "thm ctxt"} adds split tactics
  12.317 +  \<^descr> @{ML Splitter.add_split}~@{text "thm ctxt"} adds split tactics
  12.318    for @{text "thm"} as additional looper tactics of @{text "ctxt"}.
  12.319  
  12.320 -  \item @{ML Splitter.del_split}~@{text "thm ctxt"} deletes the split
  12.321 +  \<^descr> @{ML Splitter.del_split}~@{text "thm ctxt"} deletes the split
  12.322    tactic corresponding to @{text thm} from the looper tactics of
  12.323    @{text "ctxt"}.
  12.324  
  12.325 @@ -1176,7 +1176,7 @@
  12.326  
  12.327    \begin{description}
  12.328    
  12.329 -  \item @{attribute simplified}~@{text "a\<^sub>1 \<dots> a\<^sub>n"} causes a theorem to
  12.330 +  \<^descr> @{attribute simplified}~@{text "a\<^sub>1 \<dots> a\<^sub>n"} causes a theorem to
  12.331    be simplified, either by exactly the specified rules @{text "a\<^sub>1, \<dots>,
  12.332    a\<^sub>n"}, or the implicit Simplifier context if no arguments are given.
  12.333    The result is fully simplified by default, including assumptions and
  12.334 @@ -1438,11 +1438,11 @@
  12.335  
  12.336    \begin{description}
  12.337  
  12.338 -  \item @{command "print_claset"} prints the collection of rules
  12.339 +  \<^descr> @{command "print_claset"} prints the collection of rules
  12.340    declared to the Classical Reasoner, i.e.\ the @{ML_type claset}
  12.341    within the context.
  12.342  
  12.343 -  \item @{attribute intro}, @{attribute elim}, and @{attribute dest}
  12.344 +  \<^descr> @{attribute intro}, @{attribute elim}, and @{attribute dest}
  12.345    declare introduction, elimination, and destruction rules,
  12.346    respectively.  By default, rules are considered as \emph{unsafe}
  12.347    (i.e.\ not applied blindly without backtracking), while ``@{text
  12.348 @@ -1467,11 +1467,11 @@
  12.349    added with some other classification, but the rule is added anyway
  12.350    as requested.
  12.351  
  12.352 -  \item @{attribute rule}~@{text del} deletes all occurrences of a
  12.353 +  \<^descr> @{attribute rule}~@{text del} deletes all occurrences of a
  12.354    rule from the classical context, regardless of its classification as
  12.355    introduction~/ elimination~/ destruction and safe~/ unsafe.
  12.356  
  12.357 -  \item @{attribute iff} declares logical equivalences to the
  12.358 +  \<^descr> @{attribute iff} declares logical equivalences to the
  12.359    Simplifier and the Classical reasoner at the same time.
  12.360    Non-conditional rules result in a safe introduction and elimination
  12.361    pair; conditional ones are considered unsafe.  Rules with negative
  12.362 @@ -1482,7 +1482,7 @@
  12.363    the Isabelle/Pure context only, and omits the Simplifier
  12.364    declaration.
  12.365  
  12.366 -  \item @{attribute swapped} turns an introduction rule into an
  12.367 +  \<^descr> @{attribute swapped} turns an introduction rule into an
  12.368    elimination, by resolving with the classical swap principle @{text
  12.369    "\<not> P \<Longrightarrow> (\<not> R \<Longrightarrow> P) \<Longrightarrow> R"} in the second position.  This is mainly for
  12.370    illustrative purposes: the Classical Reasoner already swaps rules
  12.371 @@ -1506,7 +1506,7 @@
  12.372  
  12.373    \begin{description}
  12.374  
  12.375 -  \item @{method rule} as offered by the Classical Reasoner is a
  12.376 +  \<^descr> @{method rule} as offered by the Classical Reasoner is a
  12.377    refinement over the Pure one (see \secref{sec:pure-meth-att}).  Both
  12.378    versions work the same, but the classical version observes the
  12.379    classical rule context in addition to that of Isabelle/Pure.
  12.380 @@ -1516,7 +1516,7 @@
  12.381    ones), but only few declarations to the rule context of
  12.382    Isabelle/Pure (\secref{sec:pure-meth-att}).
  12.383  
  12.384 -  \item @{method contradiction} solves some goal by contradiction,
  12.385 +  \<^descr> @{method contradiction} solves some goal by contradiction,
  12.386    deriving any result from both @{text "\<not> A"} and @{text A}.  Chained
  12.387    facts, which are guaranteed to participate, may appear in either
  12.388    order.
  12.389 @@ -1566,7 +1566,7 @@
  12.390  
  12.391    \begin{description}
  12.392  
  12.393 -  \item @{method blast} is a separate classical tableau prover that
  12.394 +  \<^descr> @{method blast} is a separate classical tableau prover that
  12.395    uses the same classical rule declarations as explained before.
  12.396  
  12.397    Proof search is coded directly in ML using special data structures.
  12.398 @@ -1604,7 +1604,7 @@
  12.399    be made much faster by supplying the successful search bound to this
  12.400    proof method instead.
  12.401  
  12.402 -  \item @{method auto} combines classical reasoning with
  12.403 +  \<^descr> @{method auto} combines classical reasoning with
  12.404    simplification.  It is intended for situations where there are a lot
  12.405    of mostly trivial subgoals; it proves all the easy ones, leaving the
  12.406    ones it cannot prove.  Occasionally, attempting to prove the hard
  12.407 @@ -1616,12 +1616,12 @@
  12.408    for a slower but more general alternative that also takes wrappers
  12.409    into account.
  12.410  
  12.411 -  \item @{method force} is intended to prove the first subgoal
  12.412 +  \<^descr> @{method force} is intended to prove the first subgoal
  12.413    completely, using many fancy proof tools and performing a rather
  12.414    exhaustive search.  As a result, proof attempts may take rather long
  12.415    or diverge easily.
  12.416  
  12.417 -  \item @{method fast}, @{method best}, @{method slow} attempt to
  12.418 +  \<^descr> @{method fast}, @{method best}, @{method slow} attempt to
  12.419    prove the first subgoal using sequent-style reasoning as explained
  12.420    before.  Unlike @{method blast}, they construct proofs directly in
  12.421    Isabelle.
  12.422 @@ -1635,13 +1635,13 @@
  12.423    search: it may, when backtracking from a failed proof attempt, undo
  12.424    even the step of proving a subgoal by assumption.
  12.425  
  12.426 -  \item @{method fastforce}, @{method slowsimp}, @{method bestsimp}
  12.427 +  \<^descr> @{method fastforce}, @{method slowsimp}, @{method bestsimp}
  12.428    are like @{method fast}, @{method slow}, @{method best},
  12.429    respectively, but use the Simplifier as additional wrapper. The name
  12.430    @{method fastforce}, reflects the behaviour of this popular method
  12.431    better without requiring an understanding of its implementation.
  12.432  
  12.433 -  \item @{method deepen} works by exhaustive search up to a certain
  12.434 +  \<^descr> @{method deepen} works by exhaustive search up to a certain
  12.435    depth.  The start depth is 4 (unless specified explicitly), and the
  12.436    depth is increased iteratively up to 10.  Unsafe rules are modified
  12.437    to preserve the formula they act on, so that it be used repeatedly.
  12.438 @@ -1681,13 +1681,13 @@
  12.439  
  12.440    \begin{description}
  12.441  
  12.442 -  \item @{method safe} repeatedly performs safe steps on all subgoals.
  12.443 +  \<^descr> @{method safe} repeatedly performs safe steps on all subgoals.
  12.444    It is deterministic, with at most one outcome.
  12.445  
  12.446 -  \item @{method clarify} performs a series of safe steps without
  12.447 +  \<^descr> @{method clarify} performs a series of safe steps without
  12.448    splitting subgoals; see also @{method clarify_step}.
  12.449  
  12.450 -  \item @{method clarsimp} acts like @{method clarify}, but also does
  12.451 +  \<^descr> @{method clarsimp} acts like @{method clarify}, but also does
  12.452    simplification.  Note that if the Simplifier context includes a
  12.453    splitter for the premises, the subgoal may still be split.
  12.454  
  12.455 @@ -1712,25 +1712,25 @@
  12.456  
  12.457    \begin{description}
  12.458  
  12.459 -  \item @{method safe_step} performs a safe step on the first subgoal.
  12.460 +  \<^descr> @{method safe_step} performs a safe step on the first subgoal.
  12.461    The safe wrapper tacticals are applied to a tactic that may include
  12.462    proof by assumption or Modus Ponens (taking care not to instantiate
  12.463    unknowns), or substitution.
  12.464  
  12.465 -  \item @{method inst_step} is like @{method safe_step}, but allows
  12.466 +  \<^descr> @{method inst_step} is like @{method safe_step}, but allows
  12.467    unknowns to be instantiated.
  12.468  
  12.469 -  \item @{method step} is the basic step of the proof procedure, it
  12.470 +  \<^descr> @{method step} is the basic step of the proof procedure, it
  12.471    operates on the first subgoal.  The unsafe wrapper tacticals are
  12.472    applied to a tactic that tries @{method safe}, @{method inst_step},
  12.473    or applies an unsafe rule from the context.
  12.474  
  12.475 -  \item @{method slow_step} resembles @{method step}, but allows
  12.476 +  \<^descr> @{method slow_step} resembles @{method step}, but allows
  12.477    backtracking between using safe rules with instantiation (@{method
  12.478    inst_step}) and using unsafe rules.  The resulting search space is
  12.479    larger.
  12.480  
  12.481 -  \item @{method clarify_step} performs a safe step on the first
  12.482 +  \<^descr> @{method clarify_step} performs a safe step on the first
  12.483    subgoal; no splitting step is applied.  For example, the subgoal
  12.484    @{text "A \<and> B"} is left as a conjunction.  Proof by assumption,
  12.485    Modus Ponens, etc., may be performed provided they do not
  12.486 @@ -1792,40 +1792,40 @@
  12.487  
  12.488    \begin{description}
  12.489  
  12.490 -  \item @{text "ctxt addSWrapper (name, wrapper)"} adds a new wrapper,
  12.491 +  \<^descr> @{text "ctxt addSWrapper (name, wrapper)"} adds a new wrapper,
  12.492    which should yield a safe tactic, to modify the existing safe step
  12.493    tactic.
  12.494  
  12.495 -  \item @{text "ctxt addSbefore (name, tac)"} adds the given tactic as a
  12.496 +  \<^descr> @{text "ctxt addSbefore (name, tac)"} adds the given tactic as a
  12.497    safe wrapper, such that it is tried \emph{before} each safe step of
  12.498    the search.
  12.499  
  12.500 -  \item @{text "ctxt addSafter (name, tac)"} adds the given tactic as a
  12.501 +  \<^descr> @{text "ctxt addSafter (name, tac)"} adds the given tactic as a
  12.502    safe wrapper, such that it is tried when a safe step of the search
  12.503    would fail.
  12.504  
  12.505 -  \item @{text "ctxt delSWrapper name"} deletes the safe wrapper with
  12.506 +  \<^descr> @{text "ctxt delSWrapper name"} deletes the safe wrapper with
  12.507    the given name.
  12.508  
  12.509 -  \item @{text "ctxt addWrapper (name, wrapper)"} adds a new wrapper to
  12.510 +  \<^descr> @{text "ctxt addWrapper (name, wrapper)"} adds a new wrapper to
  12.511    modify the existing (unsafe) step tactic.
  12.512  
  12.513 -  \item @{text "ctxt addbefore (name, tac)"} adds the given tactic as an
  12.514 +  \<^descr> @{text "ctxt addbefore (name, tac)"} adds the given tactic as an
  12.515    unsafe wrapper, such that it its result is concatenated
  12.516    \emph{before} the result of each unsafe step.
  12.517  
  12.518 -  \item @{text "ctxt addafter (name, tac)"} adds the given tactic as an
  12.519 +  \<^descr> @{text "ctxt addafter (name, tac)"} adds the given tactic as an
  12.520    unsafe wrapper, such that it its result is concatenated \emph{after}
  12.521    the result of each unsafe step.
  12.522  
  12.523 -  \item @{text "ctxt delWrapper name"} deletes the unsafe wrapper with
  12.524 +  \<^descr> @{text "ctxt delWrapper name"} deletes the unsafe wrapper with
  12.525    the given name.
  12.526  
  12.527 -  \item @{text "addSss"} adds the simpset of the context to its
  12.528 +  \<^descr> @{text "addSss"} adds the simpset of the context to its
  12.529    classical set. The assumptions and goal will be simplified, in a
  12.530    rather safe way, after each safe step of the search.
  12.531  
  12.532 -  \item @{text "addss"} adds the simpset of the context to its
  12.533 +  \<^descr> @{text "addss"} adds the simpset of the context to its
  12.534    classical set. The assumptions and goal will be simplified, before
  12.535    the each unsafe step of the search.
  12.536  
  12.537 @@ -1874,7 +1874,7 @@
  12.538  
  12.539    \begin{description}
  12.540    
  12.541 -  \item @{command "judgment"}~@{text "c :: \<sigma> (mx)"} declares constant
  12.542 +  \<^descr> @{command "judgment"}~@{text "c :: \<sigma> (mx)"} declares constant
  12.543    @{text c} as the truth judgment of the current object-logic.  Its
  12.544    type @{text \<sigma>} should specify a coercion of the category of
  12.545    object-level propositions to @{text prop} of the Pure meta-logic;
  12.546 @@ -1883,7 +1883,7 @@
  12.547    with that of @{text prop}.  Only one @{command "judgment"}
  12.548    declaration may be given in any theory development.
  12.549    
  12.550 -  \item @{method atomize} (as a method) rewrites any non-atomic
  12.551 +  \<^descr> @{method atomize} (as a method) rewrites any non-atomic
  12.552    premises of a sub-goal, using the meta-level equations declared via
  12.553    @{attribute atomize} (as an attribute) beforehand.  As a result,
  12.554    heavily nested goals become amenable to fundamental operations such
  12.555 @@ -1898,7 +1898,7 @@
  12.556    Meta-level conjunction should be covered as well (this is
  12.557    particularly important for locales, see \secref{sec:locale}).
  12.558  
  12.559 -  \item @{attribute rule_format} rewrites a theorem by the equalities
  12.560 +  \<^descr> @{attribute rule_format} rewrites a theorem by the equalities
  12.561    declared as @{attribute rulify} rules in the current object-logic.
  12.562    By default, the result is fully normalized, including assumptions
  12.563    and conclusions at any depth.  The @{text "(no_asm)"} option
  12.564 @@ -1930,19 +1930,19 @@
  12.565  
  12.566    \begin{description}
  12.567  
  12.568 -  \item @{attribute unify_trace_simp} controls tracing of the
  12.569 +  \<^descr> @{attribute unify_trace_simp} controls tracing of the
  12.570    simplification phase of higher-order unification.
  12.571  
  12.572 -  \item @{attribute unify_trace_types} controls warnings of
  12.573 +  \<^descr> @{attribute unify_trace_types} controls warnings of
  12.574    incompleteness, when unification is not considering all possible
  12.575    instantiations of schematic type variables.
  12.576  
  12.577 -  \item @{attribute unify_trace_bound} determines the depth where
  12.578 +  \<^descr> @{attribute unify_trace_bound} determines the depth where
  12.579    unification starts to print tracing information once it reaches
  12.580    depth; 0 for full tracing.  At the default value, tracing
  12.581    information is almost never printed in practice.
  12.582  
  12.583 -  \item @{attribute unify_search_bound} prevents unification from
  12.584 +  \<^descr> @{attribute unify_search_bound} prevents unification from
  12.585    searching past the given depth.  Because of this bound, higher-order
  12.586    unification cannot return an infinite sequence, though it can return
  12.587    an exponentially long one.  The search rarely approaches the default
    13.1 --- a/src/Doc/Isar_Ref/HOL_Specific.thy	Wed Oct 14 15:06:42 2015 +0200
    13.2 +++ b/src/Doc/Isar_Ref/HOL_Specific.thy	Wed Oct 14 15:10:32 2015 +0200
    13.3 @@ -118,7 +118,7 @@
    13.4  
    13.5    \begin{description}
    13.6  
    13.7 -  \item @{command (HOL) "inductive"} and @{command (HOL)
    13.8 +  \<^descr> @{command (HOL) "inductive"} and @{command (HOL)
    13.9    "coinductive"} define (co)inductive predicates from the introduction
   13.10    rules.
   13.11  
   13.12 @@ -139,15 +139,15 @@
   13.13    \emph{monotonicity theorems}, which are required for each operator
   13.14    applied to a recursive set in the introduction rules.
   13.15  
   13.16 -  \item @{command (HOL) "inductive_set"} and @{command (HOL)
   13.17 +  \<^descr> @{command (HOL) "inductive_set"} and @{command (HOL)
   13.18    "coinductive_set"} are wrappers for to the previous commands for
   13.19    native HOL predicates.  This allows to define (co)inductive sets,
   13.20    where multiple arguments are simulated via tuples.
   13.21  
   13.22 -  \item @{command "print_inductives"} prints (co)inductive definitions and
   13.23 +  \<^descr> @{command "print_inductives"} prints (co)inductive definitions and
   13.24    monotonicity rules; the ``@{text "!"}'' option indicates extra verbosity.
   13.25  
   13.26 -  \item @{attribute (HOL) mono} declares monotonicity rules in the
   13.27 +  \<^descr> @{attribute (HOL) mono} declares monotonicity rules in the
   13.28    context.  These rule are involved in the automated monotonicity
   13.29    proof of the above inductive and coinductive definitions.
   13.30  
   13.31 @@ -162,17 +162,17 @@
   13.32  
   13.33    \begin{description}
   13.34  
   13.35 -  \item @{text R.intros} is the list of introduction rules as proven
   13.36 +  \<^descr> @{text R.intros} is the list of introduction rules as proven
   13.37    theorems, for the recursive predicates (or sets).  The rules are
   13.38    also available individually, using the names given them in the
   13.39    theory file;
   13.40  
   13.41 -  \item @{text R.cases} is the case analysis (or elimination) rule;
   13.42 -
   13.43 -  \item @{text R.induct} or @{text R.coinduct} is the (co)induction
   13.44 +  \<^descr> @{text R.cases} is the case analysis (or elimination) rule;
   13.45 +
   13.46 +  \<^descr> @{text R.induct} or @{text R.coinduct} is the (co)induction
   13.47    rule;
   13.48  
   13.49 -  \item @{text R.simps} is the equation unrolling the fixpoint of the
   13.50 +  \<^descr> @{text R.simps} is the equation unrolling the fixpoint of the
   13.51    predicate one step.
   13.52  
   13.53    \end{description}
   13.54 @@ -292,7 +292,7 @@
   13.55  
   13.56    \begin{description}
   13.57  
   13.58 -  \item @{command (HOL) "primrec"} defines primitive recursive functions
   13.59 +  \<^descr> @{command (HOL) "primrec"} defines primitive recursive functions
   13.60    over datatypes (see also @{command_ref (HOL) datatype}). The given @{text
   13.61    equations} specify reduction rules that are produced by instantiating the
   13.62    generic combinator for primitive recursion that is available for each
   13.63 @@ -315,7 +315,7 @@
   13.64    normalize expressions of @{text "f"} applied to datatype constructions, by
   13.65    simulating symbolic computation via rewriting.
   13.66  
   13.67 -  \item @{command (HOL) "function"} defines functions by general wellfounded
   13.68 +  \<^descr> @{command (HOL) "function"} defines functions by general wellfounded
   13.69    recursion. A detailed description with examples can be found in @{cite
   13.70    "isabelle-function"}. The function is specified by a set of (possibly
   13.71    conditional) recursive equations with arbitrary pattern matching. The
   13.72 @@ -328,18 +328,18 @@
   13.73    "f_dom"}. The @{command (HOL) "termination"} command can then be used to
   13.74    establish that the function is total.
   13.75  
   13.76 -  \item @{command (HOL) "fun"} is a shorthand notation for ``@{command (HOL)
   13.77 +  \<^descr> @{command (HOL) "fun"} is a shorthand notation for ``@{command (HOL)
   13.78    "function"}~@{text "(sequential)"}'', followed by automated proof attempts
   13.79    regarding pattern matching and termination. See @{cite
   13.80    "isabelle-function"} for further details.
   13.81  
   13.82 -  \item @{command (HOL) "termination"}~@{text f} commences a termination
   13.83 +  \<^descr> @{command (HOL) "termination"}~@{text f} commences a termination
   13.84    proof for the previously defined function @{text f}. If this is omitted,
   13.85    the command refers to the most recent function definition. After the proof
   13.86    is closed, the recursive equations and the induction principle is
   13.87    established.
   13.88  
   13.89 -  \item @{command (HOL) "fun_cases"} generates specialized elimination rules
   13.90 +  \<^descr> @{command (HOL) "fun_cases"} generates specialized elimination rules
   13.91    for function equations. It expects one or more function equations and
   13.92    produces rules that eliminate the given equalities, following the cases
   13.93    given in the function definition.
   13.94 @@ -362,7 +362,7 @@
   13.95  
   13.96    \begin{description}
   13.97  
   13.98 -  \item @{text sequential} enables a preprocessor which disambiguates
   13.99 +  \<^descr> @{text sequential} enables a preprocessor which disambiguates
  13.100    overlapping patterns by making them mutually disjoint. Earlier equations
  13.101    take precedence over later ones. This allows to give the specification in
  13.102    a format very similar to functional programming. Note that the resulting
  13.103 @@ -371,7 +371,7 @@
  13.104    equation given by the user may result in several theorems. Also note that
  13.105    this automatic transformation only works for ML-style datatype patterns.
  13.106  
  13.107 -  \item @{text domintros} enables the automated generation of introduction
  13.108 +  \<^descr> @{text domintros} enables the automated generation of introduction
  13.109    rules for the domain predicate. While mostly not needed, they can be
  13.110    helpful in some proofs about partial functions.
  13.111  
  13.112 @@ -537,19 +537,19 @@
  13.113  
  13.114    \begin{description}
  13.115  
  13.116 -  \item @{method (HOL) pat_completeness} is a specialized method to
  13.117 +  \<^descr> @{method (HOL) pat_completeness} is a specialized method to
  13.118    solve goals regarding the completeness of pattern matching, as
  13.119    required by the @{command (HOL) "function"} package (cf.\
  13.120    @{cite "isabelle-function"}).
  13.121  
  13.122 -  \item @{method (HOL) relation}~@{text R} introduces a termination
  13.123 +  \<^descr> @{method (HOL) relation}~@{text R} introduces a termination
  13.124    proof using the relation @{text R}.  The resulting proof state will
  13.125    contain goals expressing that @{text R} is wellfounded, and that the
  13.126    arguments of recursive calls decrease with respect to @{text R}.
  13.127    Usually, this method is used as the initial proof step of manual
  13.128    termination proofs.
  13.129  
  13.130 -  \item @{method (HOL) "lexicographic_order"} attempts a fully
  13.131 +  \<^descr> @{method (HOL) "lexicographic_order"} attempts a fully
  13.132    automated termination proof by searching for a lexicographic
  13.133    combination of size measures on the arguments of the function. The
  13.134    method accepts the same arguments as the @{method auto} method,
  13.135 @@ -559,7 +559,7 @@
  13.136    In case of failure, extensive information is printed, which can help
  13.137    to analyse the situation (cf.\ @{cite "isabelle-function"}).
  13.138  
  13.139 -  \item @{method (HOL) "size_change"} also works on termination goals,
  13.140 +  \<^descr> @{method (HOL) "size_change"} also works on termination goals,
  13.141    using a variation of the size-change principle, together with a
  13.142    graph decomposition technique (see @{cite krauss_phd} for details).
  13.143    Three kinds of orders are used internally: @{text max}, @{text min},
  13.144 @@ -571,7 +571,7 @@
  13.145    For local descent proofs, the @{syntax clasimpmod} modifiers are
  13.146    accepted (as for @{method auto}).
  13.147  
  13.148 -  \item @{method (HOL) induction_schema} derives user-specified
  13.149 +  \<^descr> @{method (HOL) induction_schema} derives user-specified
  13.150    induction rules from well-founded induction and completeness of
  13.151    patterns. This factors out some operations that are done internally
  13.152    by the function package and makes them available separately. See
  13.153 @@ -596,7 +596,7 @@
  13.154  
  13.155    \begin{description}
  13.156  
  13.157 -  \item @{command (HOL) "partial_function"}~@{text "(mode)"} defines
  13.158 +  \<^descr> @{command (HOL) "partial_function"}~@{text "(mode)"} defines
  13.159    recursive functions based on fixpoints in complete partial
  13.160    orders. No termination proof is required from the user or
  13.161    constructed internally. Instead, the possibility of non-termination
  13.162 @@ -621,14 +621,14 @@
  13.163  
  13.164    \begin{description}
  13.165  
  13.166 -  \item @{text option} defines functions that map into the @{type
  13.167 +  \<^descr> @{text option} defines functions that map into the @{type
  13.168    option} type. Here, the value @{term None} is used to model a
  13.169    non-terminating computation. Monotonicity requires that if @{term
  13.170    None} is returned by a recursive call, then the overall result must
  13.171    also be @{term None}. This is best achieved through the use of the
  13.172    monadic operator @{const "Option.bind"}.
  13.173  
  13.174 -  \item @{text tailrec} defines functions with an arbitrary result
  13.175 +  \<^descr> @{text tailrec} defines functions with an arbitrary result
  13.176    type and uses the slightly degenerated partial order where @{term
  13.177    "undefined"} is the bottom element.  Now, monotonicity requires that
  13.178    if @{term undefined} is returned by a recursive call, then the
  13.179 @@ -642,7 +642,7 @@
  13.180    Experienced users may define new modes by instantiating the locale
  13.181    @{const "partial_function_definitions"} appropriately.
  13.182  
  13.183 -  \item @{attribute (HOL) partial_function_mono} declares rules for
  13.184 +  \<^descr> @{attribute (HOL) partial_function_mono} declares rules for
  13.185    use in the internal monotonicity proofs of partial function
  13.186    definitions.
  13.187  
  13.188 @@ -673,7 +673,7 @@
  13.189  
  13.190    \begin{description}
  13.191  
  13.192 -  \item @{command (HOL) "recdef"} defines general well-founded
  13.193 +  \<^descr> @{command (HOL) "recdef"} defines general well-founded
  13.194    recursive functions (using the TFL package), see also
  13.195    @{cite "isabelle-HOL"}.  The ``@{text "(permissive)"}'' option tells
  13.196    TFL to recover from failed proof attempts, returning unfinished
  13.197 @@ -727,14 +727,14 @@
  13.198  
  13.199    \begin{description}
  13.200  
  13.201 -  \item @{command "adhoc_overloading"}~@{text "c v\<^sub>1 ... v\<^sub>n"}
  13.202 +  \<^descr> @{command "adhoc_overloading"}~@{text "c v\<^sub>1 ... v\<^sub>n"}
  13.203    associates variants with an existing constant.
  13.204  
  13.205 -  \item @{command "no_adhoc_overloading"} is similar to
  13.206 +  \<^descr> @{command "no_adhoc_overloading"} is similar to
  13.207    @{command "adhoc_overloading"}, but removes the specified variants
  13.208    from the present context.
  13.209  
  13.210 -  \item @{attribute "show_variants"} controls printing of variants
  13.211 +  \<^descr> @{attribute "show_variants"} controls printing of variants
  13.212    of overloaded constants. If enabled, the internally used variants
  13.213    are printed instead of their respective overloaded constants. This
  13.214    is occasionally useful to check whether the system agrees with a
  13.215 @@ -760,7 +760,7 @@
  13.216  
  13.217    \begin{description}
  13.218  
  13.219 -  \item @{command (HOL) "specification"}~@{text "decls \<phi>"} sets up a
  13.220 +  \<^descr> @{command (HOL) "specification"}~@{text "decls \<phi>"} sets up a
  13.221    goal stating the existence of terms with the properties specified to
  13.222    hold for the constants given in @{text decls}.  After finishing the
  13.223    proof, the theory will be augmented with definitions for the given
  13.224 @@ -797,10 +797,10 @@
  13.225  
  13.226    \begin{description}
  13.227  
  13.228 -  \item @{command (HOL) "old_datatype"} defines old-style inductive
  13.229 +  \<^descr> @{command (HOL) "old_datatype"} defines old-style inductive
  13.230    datatypes in HOL.
  13.231  
  13.232 -  \item @{command (HOL) "old_rep_datatype"} represents existing types as
  13.233 +  \<^descr> @{command (HOL) "old_rep_datatype"} represents existing types as
  13.234    old-style datatypes.
  13.235  
  13.236    \end{description}
  13.237 @@ -945,7 +945,7 @@
  13.238  
  13.239    \begin{description}
  13.240  
  13.241 -  \item @{command (HOL) "record"}~@{text "(\<alpha>\<^sub>1, \<dots>, \<alpha>\<^sub>m) t = \<tau> + c\<^sub>1 :: \<sigma>\<^sub>1
  13.242 +  \<^descr> @{command (HOL) "record"}~@{text "(\<alpha>\<^sub>1, \<dots>, \<alpha>\<^sub>m) t = \<tau> + c\<^sub>1 :: \<sigma>\<^sub>1
  13.243    \<dots> c\<^sub>n :: \<sigma>\<^sub>n"} defines extensible record type @{text "(\<alpha>\<^sub>1, \<dots>, \<alpha>\<^sub>m) t"},
  13.244    derived from the optional parent record @{text "\<tau>"} by adding new
  13.245    field components @{text "c\<^sub>i :: \<sigma>\<^sub>i"} etc.
  13.246 @@ -1179,7 +1179,7 @@
  13.247  
  13.248    \begin{description}
  13.249  
  13.250 -  \item @{command (HOL) "typedef"}~@{text "(\<alpha>\<^sub>1, \<dots>, \<alpha>\<^sub>n) t = A"} defines a
  13.251 +  \<^descr> @{command (HOL) "typedef"}~@{text "(\<alpha>\<^sub>1, \<dots>, \<alpha>\<^sub>n) t = A"} defines a
  13.252    new type @{text "(\<alpha>\<^sub>1, \<dots>, \<alpha>\<^sub>n) t"} from the set @{text A} over an existing
  13.253    type. The set @{text A} may contain type variables @{text "\<alpha>\<^sub>1, \<dots>, \<alpha>\<^sub>n"}
  13.254    as specified on the LHS, but no term variables. Non-emptiness of @{text A}
  13.255 @@ -1274,7 +1274,7 @@
  13.256  
  13.257    \begin{description}
  13.258  
  13.259 -  \item @{command (HOL) "functor"}~@{text "prefix: m"} allows to prove and
  13.260 +  \<^descr> @{command (HOL) "functor"}~@{text "prefix: m"} allows to prove and
  13.261    register properties about the functorial structure of type constructors.
  13.262    These properties then can be used by other packages to deal with those
  13.263    type constructors in certain type constructions. Characteristic theorems
  13.264 @@ -1332,7 +1332,7 @@
  13.265  
  13.266    \begin{description}
  13.267  
  13.268 -  \item @{command (HOL) "quotient_type"} defines a new quotient type @{text
  13.269 +  \<^descr> @{command (HOL) "quotient_type"} defines a new quotient type @{text
  13.270    \<tau>}. The injection from a quotient type to a raw type is called @{text
  13.271    rep_\<tau>}, its inverse @{text abs_\<tau>} unless explicit @{keyword (HOL)
  13.272    "morphisms"} specification provides alternative names. @{command (HOL)
  13.273 @@ -1407,7 +1407,7 @@
  13.274  
  13.275    \begin{description}
  13.276  
  13.277 -  \item @{command (HOL) "setup_lifting"} Sets up the Lifting package to work
  13.278 +  \<^descr> @{command (HOL) "setup_lifting"} Sets up the Lifting package to work
  13.279    with a user-defined type. The command supports two modes.
  13.280  
  13.281    \begin{enumerate}
  13.282 @@ -1446,7 +1446,7 @@
  13.283    by @{command (HOL) "lift_definition"}, the Lifting package proves and
  13.284    registers a code equation (if there is one) for the new constant.
  13.285  
  13.286 -  \item @{command (HOL) "lift_definition"} @{text "f :: \<tau>"} @{keyword (HOL)
  13.287 +  \<^descr> @{command (HOL) "lift_definition"} @{text "f :: \<tau>"} @{keyword (HOL)
  13.288    "is"} @{text t} Defines a new function @{text f} with an abstract type
  13.289    @{text \<tau>} in terms of a corresponding operation @{text t} on a
  13.290    representation type. More formally, if @{text "t :: \<sigma>"}, then the command
  13.291 @@ -1490,12 +1490,14 @@
  13.292  
  13.293    \begin{description}
  13.294  
  13.295 -  \item @{text "\<tau>"} is a type variable \item @{text "\<tau> = \<tau>\<^sub>1 \<dots> \<tau>\<^sub>n \<kappa>"},
  13.296 +  \<^descr> @{text "\<tau>"} is a type variable
  13.297 +
  13.298 +  \<^descr> @{text "\<tau> = \<tau>\<^sub>1 \<dots> \<tau>\<^sub>n \<kappa>"},
  13.299    where @{text "\<kappa>"} is an abstract type constructor and @{text "\<tau>\<^sub>1 \<dots> \<tau>\<^sub>n"}
  13.300    do not contain abstract types (i.e.\ @{typ "int dlist"} is allowed whereas
  13.301    @{typ "int dlist dlist"} not)
  13.302  
  13.303 -  \item @{text "\<tau> = \<tau>\<^sub>1 \<dots> \<tau>\<^sub>n \<kappa>"}, @{text "\<kappa>"} is a type constructor that
  13.304 +  \<^descr> @{text "\<tau> = \<tau>\<^sub>1 \<dots> \<tau>\<^sub>n \<kappa>"}, @{text "\<kappa>"} is a type constructor that
  13.305    was defined as a (co)datatype whose constructor argument types do not
  13.306    contain either non-free datatypes or the function type.
  13.307  
  13.308 @@ -1505,7 +1507,7 @@
  13.309    @{command (HOL) "lift_definition"} uses @{text f.abs_eq} as a code
  13.310    equation.
  13.311  
  13.312 -  \item @{command (HOL) lifting_forget} and @{command (HOL) lifting_update}
  13.313 +  \<^descr> @{command (HOL) lifting_forget} and @{command (HOL) lifting_update}
  13.314    These two commands serve for storing and deleting the set-up of the
  13.315    Lifting package and corresponding transfer rules defined by this package.
  13.316    This is useful for hiding of type construction details of an abstract type
  13.317 @@ -1528,19 +1530,19 @@
  13.318    including a bundle (@{command "include"}, @{keyword "includes"} and
  13.319    @{command "including"}).
  13.320  
  13.321 -  \item @{command (HOL) "print_quot_maps"} prints stored quotient map
  13.322 +  \<^descr> @{command (HOL) "print_quot_maps"} prints stored quotient map
  13.323    theorems.
  13.324  
  13.325 -  \item @{command (HOL) "print_quotients"} prints stored quotient theorems.
  13.326 -
  13.327 -  \item @{attribute (HOL) quot_map} registers a quotient map theorem, a
  13.328 +  \<^descr> @{command (HOL) "print_quotients"} prints stored quotient theorems.
  13.329 +
  13.330 +  \<^descr> @{attribute (HOL) quot_map} registers a quotient map theorem, a
  13.331    theorem showing how to ``lift'' quotients over type constructors. E.g.\
  13.332    @{term "Quotient R Abs Rep T \<Longrightarrow> Quotient (rel_set R) (image Abs) (image
  13.333    Rep) (rel_set T)"}. For examples see @{file "~~/src/HOL/Lifting_Set.thy"}
  13.334    or @{file "~~/src/HOL/Lifting.thy"}. This property is proved automatically
  13.335    if the involved type is BNF without dead variables.
  13.336  
  13.337 -  \item @{attribute (HOL) relator_eq_onp} registers a theorem that shows
  13.338 +  \<^descr> @{attribute (HOL) relator_eq_onp} registers a theorem that shows
  13.339    that a relator applied to an equality restricted by a predicate @{term P}
  13.340    (i.e.\ @{term "eq_onp P"}) is equal to a predicator applied to the @{term
  13.341    P}. The combinator @{const eq_onp} is used for internal encoding of proper
  13.342 @@ -1550,7 +1552,7 @@
  13.343    This property is proved automatically if the involved type is BNF without
  13.344    dead variables.
  13.345  
  13.346 -  \item @{attribute (HOL) "relator_mono"} registers a property describing a
  13.347 +  \<^descr> @{attribute (HOL) "relator_mono"} registers a property describing a
  13.348    monotonicity of a relator. E.g.\ @{prop "A \<le> B \<Longrightarrow> rel_set A \<le> rel_set B"}.
  13.349    This property is needed for proving a stronger transfer rule in
  13.350    @{command_def (HOL) "lift_definition"} when a parametricity theorem for
  13.351 @@ -1559,7 +1561,7 @@
  13.352    "~~/src/HOL/Lifting.thy"}. This property is proved automatically if the
  13.353    involved type is BNF without dead variables.
  13.354  
  13.355 -  \item @{attribute (HOL) "relator_distr"} registers a property describing a
  13.356 +  \<^descr> @{attribute (HOL) "relator_distr"} registers a property describing a
  13.357    distributivity of the relation composition and a relator. E.g.\ @{text
  13.358    "rel_set R \<circ>\<circ> rel_set S = rel_set (R \<circ>\<circ> S)"}. This property is needed for
  13.359    proving a stronger transfer rule in @{command_def (HOL) "lift_definition"}
  13.360 @@ -1573,14 +1575,14 @@
  13.361    property is proved automatically if the involved type is BNF without dead
  13.362    variables.
  13.363  
  13.364 -  \item @{attribute (HOL) quot_del} deletes a corresponding Quotient theorem
  13.365 +  \<^descr> @{attribute (HOL) quot_del} deletes a corresponding Quotient theorem
  13.366    from the Lifting infrastructure and thus de-register the corresponding
  13.367    quotient. This effectively causes that @{command (HOL) lift_definition}
  13.368    will not do any lifting for the corresponding type. This attribute is
  13.369    rather used for low-level manipulation with set-up of the Lifting package
  13.370    because @{command (HOL) lifting_forget} is preferred for normal usage.
  13.371  
  13.372 -  \item @{attribute (HOL) lifting_restore} @{text "Quotient_thm pcr_def
  13.373 +  \<^descr> @{attribute (HOL) lifting_restore} @{text "Quotient_thm pcr_def
  13.374    pcr_cr_eq_thm"} registers the Quotient theorem @{text Quotient_thm} in the
  13.375    Lifting infrastructure and thus sets up lifting for an abstract type
  13.376    @{text \<tau>} (that is defined by @{text Quotient_thm}). Optional theorems
  13.377 @@ -1593,7 +1595,7 @@
  13.378    together with the commands @{command (HOL) lifting_forget} and @{command
  13.379    (HOL) lifting_update} is preferred for normal usage.
  13.380  
  13.381 -  \item Integration with the BNF package @{cite "isabelle-datatypes"}: As
  13.382 +  \<^descr> Integration with the BNF package @{cite "isabelle-datatypes"}: As
  13.383    already mentioned, the theorems that are registered by the following
  13.384    attributes are proved and registered automatically if the involved type is
  13.385    BNF without dead variables: @{attribute (HOL) quot_map}, @{attribute (HOL)
  13.386 @@ -1628,25 +1630,25 @@
  13.387  
  13.388    \begin{description}
  13.389  
  13.390 -  \item @{method (HOL) "transfer"} method replaces the current subgoal with
  13.391 +  \<^descr> @{method (HOL) "transfer"} method replaces the current subgoal with
  13.392    a logically equivalent one that uses different types and constants. The
  13.393    replacement of types and constants is guided by the database of transfer
  13.394    rules. Goals are generalized over all free variables by default; this is
  13.395    necessary for variables whose types change, but can be overridden for
  13.396    specific variables with e.g. @{text "transfer fixing: x y z"}.
  13.397  
  13.398 -  \item @{method (HOL) "transfer'"} is a variant of @{method (HOL) transfer}
  13.399 +  \<^descr> @{method (HOL) "transfer'"} is a variant of @{method (HOL) transfer}
  13.400    that allows replacing a subgoal with one that is logically stronger
  13.401    (rather than equivalent). For example, a subgoal involving equality on a
  13.402    quotient type could be replaced with a subgoal involving equality (instead
  13.403    of the corresponding equivalence relation) on the underlying raw type.
  13.404  
  13.405 -  \item @{method (HOL) "transfer_prover"} method assists with proving a
  13.406 +  \<^descr> @{method (HOL) "transfer_prover"} method assists with proving a
  13.407    transfer rule for a new constant, provided the constant is defined in
  13.408    terms of other constants that already have transfer rules. It should be
  13.409    applied after unfolding the constant definitions.
  13.410  
  13.411 -  \item @{method (HOL) "transfer_start"}, @{method (HOL) "transfer_step"},
  13.412 +  \<^descr> @{method (HOL) "transfer_start"}, @{method (HOL) "transfer_step"},
  13.413    @{method (HOL) "transfer_end"}, @{method (HOL) "transfer_prover_start"}
  13.414    and @{method (HOL) "transfer_prover_end"} methods are meant to be used
  13.415    for debugging of @{method (HOL) "transfer"} and @{method (HOL) "transfer_prover"},
  13.416 @@ -1657,17 +1659,17 @@
  13.417    @{method (HOL) "transfer_step"}+, @{method (HOL) "transfer_prover_end"}).
  13.418    For usage examples see @{file "~~/src/HOL/ex/Transfer_Debug.thy"} 
  13.419  
  13.420 -  \item @{attribute (HOL) "untransferred"} proves the same equivalent
  13.421 +  \<^descr> @{attribute (HOL) "untransferred"} proves the same equivalent
  13.422    theorem as @{method (HOL) "transfer"} internally does.
  13.423  
  13.424 -  \item @{attribute (HOL) Transfer.transferred} works in the opposite
  13.425 +  \<^descr> @{attribute (HOL) Transfer.transferred} works in the opposite
  13.426    direction than @{method (HOL) "transfer'"}. E.g.\ given the transfer
  13.427    relation @{text "ZN x n \<equiv> (x = int n)"}, corresponding transfer rules and
  13.428    the theorem @{text "\<forall>x::int \<in> {0..}. x < x + 1"}, the attribute would
  13.429    prove @{text "\<forall>n::nat. n < n + 1"}. The attribute is still in experimental
  13.430    phase of development.
  13.431  
  13.432 -  \item @{attribute (HOL) "transfer_rule"} attribute maintains a collection
  13.433 +  \<^descr> @{attribute (HOL) "transfer_rule"} attribute maintains a collection
  13.434    of transfer rules, which relate constants at two different types. Typical
  13.435    transfer rules may relate different type instances of the same polymorphic
  13.436    constant, or they may relate an operation on a raw type to a corresponding
  13.437 @@ -1687,14 +1689,14 @@
  13.438    a relator is proved automatically if the involved type is BNF @{cite
  13.439    "isabelle-datatypes"} without dead variables.
  13.440  
  13.441 -  \item @{attribute (HOL) "transfer_domain_rule"} attribute maintains a
  13.442 +  \<^descr> @{attribute (HOL) "transfer_domain_rule"} attribute maintains a
  13.443    collection of rules, which specify a domain of a transfer relation by a
  13.444    predicate. E.g.\ given the transfer relation @{text "ZN x n \<equiv> (x = int
  13.445    n)"}, one can register the following transfer domain rule: @{text "Domainp
  13.446    ZN = (\<lambda>x. x \<ge> 0)"}. The rules allow the package to produce more readable
  13.447    transferred goals, e.g.\ when quantifiers are transferred.
  13.448  
  13.449 -  \item @{attribute (HOL) relator_eq} attribute collects identity laws for
  13.450 +  \<^descr> @{attribute (HOL) relator_eq} attribute collects identity laws for
  13.451    relators of various type constructors, e.g. @{term "rel_set (op =) = (op
  13.452    =)"}. The @{method (HOL) transfer} method uses these lemmas to infer
  13.453    transfer rules for non-polymorphic constants on the fly. For examples see
  13.454 @@ -1702,7 +1704,7 @@
  13.455    This property is proved automatically if the involved type is BNF without
  13.456    dead variables.
  13.457  
  13.458 -  \item @{attribute_def (HOL) "relator_domain"} attribute collects rules
  13.459 +  \<^descr> @{attribute_def (HOL) "relator_domain"} attribute collects rules
  13.460    describing domains of relators by predicators. E.g.\ @{term "Domainp
  13.461    (rel_set T) = (\<lambda>A. Ball A (Domainp T))"}. This allows the package to lift
  13.462    transfer domain rules through type constructors. For examples see @{file
  13.463 @@ -1753,16 +1755,16 @@
  13.464  
  13.465    \begin{description}
  13.466  
  13.467 -  \item @{command (HOL) "quotient_definition"} defines a constant on the
  13.468 +  \<^descr> @{command (HOL) "quotient_definition"} defines a constant on the
  13.469    quotient type.
  13.470  
  13.471 -  \item @{command (HOL) "print_quotmapsQ3"} prints quotient map functions.
  13.472 -
  13.473 -  \item @{command (HOL) "print_quotientsQ3"} prints quotients.
  13.474 -
  13.475 -  \item @{command (HOL) "print_quotconsts"} prints quotient constants.
  13.476 -
  13.477 -  \item @{method (HOL) "lifting"} and @{method (HOL) "lifting_setup"}
  13.478 +  \<^descr> @{command (HOL) "print_quotmapsQ3"} prints quotient map functions.
  13.479 +
  13.480 +  \<^descr> @{command (HOL) "print_quotientsQ3"} prints quotients.
  13.481 +
  13.482 +  \<^descr> @{command (HOL) "print_quotconsts"} prints quotient constants.
  13.483 +
  13.484 +  \<^descr> @{method (HOL) "lifting"} and @{method (HOL) "lifting_setup"}
  13.485    methods match the current goal with the given raw theorem to be lifted
  13.486    producing three new subgoals: regularization, injection and cleaning
  13.487    subgoals. @{method (HOL) "lifting"} tries to apply the heuristics for
  13.488 @@ -1770,7 +1772,7 @@
  13.489    unsolved by the heuristics to the user as opposed to @{method (HOL)
  13.490    "lifting_setup"} which leaves the three subgoals unsolved.
  13.491  
  13.492 -  \item @{method (HOL) "descending"} and @{method (HOL) "descending_setup"}
  13.493 +  \<^descr> @{method (HOL) "descending"} and @{method (HOL) "descending_setup"}
  13.494    try to guess a raw statement that would lift to the current subgoal. Such
  13.495    statement is assumed as a new subgoal and @{method (HOL) "descending"}
  13.496    continues in the same way as @{method (HOL) "lifting"} does. @{method
  13.497 @@ -1778,34 +1780,34 @@
  13.498    and cleaning subgoals with the analogous method @{method (HOL)
  13.499    "descending_setup"} which leaves the four unsolved subgoals.
  13.500  
  13.501 -  \item @{method (HOL) "partiality_descending"} finds the regularized
  13.502 +  \<^descr> @{method (HOL) "partiality_descending"} finds the regularized
  13.503    theorem that would lift to the current subgoal, lifts it and leaves as a
  13.504    subgoal. This method can be used with partial equivalence quotients where
  13.505    the non regularized statements would not be true. @{method (HOL)
  13.506    "partiality_descending_setup"} leaves the injection and cleaning subgoals
  13.507    unchanged.
  13.508  
  13.509 -  \item @{method (HOL) "regularize"} applies the regularization heuristics
  13.510 +  \<^descr> @{method (HOL) "regularize"} applies the regularization heuristics
  13.511    to the current subgoal.
  13.512  
  13.513 -  \item @{method (HOL) "injection"} applies the injection heuristics to the
  13.514 +  \<^descr> @{method (HOL) "injection"} applies the injection heuristics to the
  13.515    current goal using the stored quotient respectfulness theorems.
  13.516  
  13.517 -  \item @{method (HOL) "cleaning"} applies the injection cleaning heuristics
  13.518 +  \<^descr> @{method (HOL) "cleaning"} applies the injection cleaning heuristics
  13.519    to the current subgoal using the stored quotient preservation theorems.
  13.520  
  13.521 -  \item @{attribute (HOL) quot_lifted} attribute tries to automatically
  13.522 +  \<^descr> @{attribute (HOL) quot_lifted} attribute tries to automatically
  13.523    transport the theorem to the quotient type. The attribute uses all the
  13.524    defined quotients types and quotient constants often producing undesired
  13.525    results or theorems that cannot be lifted.
  13.526  
  13.527 -  \item @{attribute (HOL) quot_respect} and @{attribute (HOL) quot_preserve}
  13.528 +  \<^descr> @{attribute (HOL) quot_respect} and @{attribute (HOL) quot_preserve}
  13.529    attributes declare a theorem as a respectfulness and preservation theorem
  13.530    respectively. These are stored in the local theory store and used by the
  13.531    @{method (HOL) "injection"} and @{method (HOL) "cleaning"} methods
  13.532    respectively.
  13.533  
  13.534 -  \item @{attribute (HOL) quot_thm} declares that a certain theorem is a
  13.535 +  \<^descr> @{attribute (HOL) quot_thm} declares that a certain theorem is a
  13.536    quotient extension theorem. Quotient extension theorems allow for
  13.537    quotienting inside container types. Given a polymorphic type that serves
  13.538    as a container, a map function defined for this container using @{command
  13.539 @@ -1855,28 +1857,28 @@
  13.540  
  13.541    \begin{description}
  13.542  
  13.543 -  \item @{command (HOL) "solve_direct"} checks whether the current
  13.544 +  \<^descr> @{command (HOL) "solve_direct"} checks whether the current
  13.545    subgoals can be solved directly by an existing theorem. Duplicate
  13.546    lemmas can be detected in this way.
  13.547  
  13.548 -  \item @{command (HOL) "try0"} attempts to prove a subgoal
  13.549 +  \<^descr> @{command (HOL) "try0"} attempts to prove a subgoal
  13.550    using a combination of standard proof methods (@{method auto},
  13.551    @{method simp}, @{method blast}, etc.).  Additional facts supplied
  13.552    via @{text "simp:"}, @{text "intro:"}, @{text "elim:"}, and @{text
  13.553    "dest:"} are passed to the appropriate proof methods.
  13.554  
  13.555 -  \item @{command (HOL) "try"} attempts to prove or disprove a subgoal
  13.556 +  \<^descr> @{command (HOL) "try"} attempts to prove or disprove a subgoal
  13.557    using a combination of provers and disprovers (@{command (HOL)
  13.558    "solve_direct"}, @{command (HOL) "quickcheck"}, @{command (HOL)
  13.559    "try0"}, @{command (HOL) "sledgehammer"}, @{command (HOL)
  13.560    "nitpick"}).
  13.561  
  13.562 -  \item @{command (HOL) "sledgehammer"} attempts to prove a subgoal
  13.563 +  \<^descr> @{command (HOL) "sledgehammer"} attempts to prove a subgoal
  13.564    using external automatic provers (resolution provers and SMT
  13.565    solvers). See the Sledgehammer manual @{cite "isabelle-sledgehammer"}
  13.566    for details.
  13.567  
  13.568 -  \item @{command (HOL) "sledgehammer_params"} changes @{command (HOL)
  13.569 +  \<^descr> @{command (HOL) "sledgehammer_params"} changes @{command (HOL)
  13.570    "sledgehammer"} configuration options persistently.
  13.571  
  13.572    \end{description}
  13.573 @@ -1929,7 +1931,7 @@
  13.574  
  13.575    \begin{description}
  13.576  
  13.577 -  \item @{command (HOL) "value"}~@{text t} evaluates and prints a
  13.578 +  \<^descr> @{command (HOL) "value"}~@{text t} evaluates and prints a
  13.579    term; optionally @{text modes} can be specified, which are appended
  13.580    to the current print mode; see \secref{sec:print-modes}.
  13.581    Evaluation is tried first using ML, falling
  13.582 @@ -1940,13 +1942,13 @@
  13.583    using the simplifier, @{text nbe} for \emph{normalization by
  13.584    evaluation} and \emph{code} for code generation in SML.
  13.585  
  13.586 -  \item @{command (HOL) "values"}~@{text t} enumerates a set
  13.587 +  \<^descr> @{command (HOL) "values"}~@{text t} enumerates a set
  13.588    comprehension by evaluation and prints its values up to the given
  13.589    number of solutions; optionally @{text modes} can be specified,
  13.590    which are appended to the current print mode; see
  13.591    \secref{sec:print-modes}.
  13.592  
  13.593 -  \item @{command (HOL) "quickcheck"} tests the current goal for
  13.594 +  \<^descr> @{command (HOL) "quickcheck"} tests the current goal for
  13.595    counterexamples using a series of assignments for its free
  13.596    variables; by default the first subgoal is tested, an other can be
  13.597    selected explicitly using an optional goal index.  Assignments can
  13.598 @@ -1958,7 +1960,7 @@
  13.599  
  13.600      \begin{description}
  13.601  
  13.602 -    \item[@{text tester}] specifies which testing approach to apply.
  13.603 +    \<^descr>[@{text tester}] specifies which testing approach to apply.
  13.604      There are three testers, @{text exhaustive}, @{text random}, and
  13.605      @{text narrowing}.  An unknown configuration option is treated as
  13.606      an argument to tester, making @{text "tester ="} optional.  When
  13.607 @@ -1969,31 +1971,31 @@
  13.608      quickcheck_random_active}, @{attribute
  13.609      quickcheck_narrowing_active} are set to true.
  13.610  
  13.611 -    \item[@{text size}] specifies the maximum size of the search space
  13.612 +    \<^descr>[@{text size}] specifies the maximum size of the search space
  13.613      for assignment values.
  13.614  
  13.615 -    \item[@{text genuine_only}] sets quickcheck only to return genuine
  13.616 +    \<^descr>[@{text genuine_only}] sets quickcheck only to return genuine
  13.617      counterexample, but not potentially spurious counterexamples due
  13.618      to underspecified functions.
  13.619  
  13.620 -    \item[@{text abort_potential}] sets quickcheck to abort once it
  13.621 +    \<^descr>[@{text abort_potential}] sets quickcheck to abort once it
  13.622      found a potentially spurious counterexample and to not continue
  13.623      to search for a further genuine counterexample.
  13.624      For this option to be effective, the @{text genuine_only} option
  13.625      must be set to false.
  13.626  
  13.627 -    \item[@{text eval}] takes a term or a list of terms and evaluates
  13.628 +    \<^descr>[@{text eval}] takes a term or a list of terms and evaluates
  13.629      these terms under the variable assignment found by quickcheck.
  13.630      This option is currently only supported by the default
  13.631      (exhaustive) tester.
  13.632  
  13.633 -    \item[@{text iterations}] sets how many sets of assignments are
  13.634 +    \<^descr>[@{text iterations}] sets how many sets of assignments are
  13.635      generated for each particular size.
  13.636  
  13.637 -    \item[@{text no_assms}] specifies whether assumptions in
  13.638 +    \<^descr>[@{text no_assms}] specifies whether assumptions in
  13.639      structured proofs should be ignored.
  13.640  
  13.641 -    \item[@{text locale}] specifies how to process conjectures in
  13.642 +    \<^descr>[@{text locale}] specifies how to process conjectures in
  13.643      a locale context, i.e.\ they can be interpreted or expanded.
  13.644      The option is a whitespace-separated list of the two words
  13.645      @{text interpret} and @{text expand}. The list determines the
  13.646 @@ -2002,25 +2004,25 @@
  13.647      The option is only provided as attribute declaration, but not
  13.648      as parameter to the command.
  13.649  
  13.650 -    \item[@{text timeout}] sets the time limit in seconds.
  13.651 -
  13.652 -    \item[@{text default_type}] sets the type(s) generally used to
  13.653 +    \<^descr>[@{text timeout}] sets the time limit in seconds.
  13.654 +
  13.655 +    \<^descr>[@{text default_type}] sets the type(s) generally used to
  13.656      instantiate type variables.
  13.657  
  13.658 -    \item[@{text report}] if set quickcheck reports how many tests
  13.659 +    \<^descr>[@{text report}] if set quickcheck reports how many tests
  13.660      fulfilled the preconditions.
  13.661  
  13.662 -    \item[@{text use_subtype}] if set quickcheck automatically lifts
  13.663 +    \<^descr>[@{text use_subtype}] if set quickcheck automatically lifts
  13.664      conjectures to registered subtypes if possible, and tests the
  13.665      lifted conjecture.
  13.666  
  13.667 -    \item[@{text quiet}] if set quickcheck does not output anything
  13.668 +    \<^descr>[@{text quiet}] if set quickcheck does not output anything
  13.669      while testing.
  13.670  
  13.671 -    \item[@{text verbose}] if set quickcheck informs about the current
  13.672 +    \<^descr>[@{text verbose}] if set quickcheck informs about the current
  13.673      size and cardinality while testing.
  13.674  
  13.675 -    \item[@{text expect}] can be used to check if the user's
  13.676 +    \<^descr>[@{text expect}] can be used to check if the user's
  13.677      expectation was met (@{text no_expectation}, @{text
  13.678      no_counterexample}, or @{text counterexample}).
  13.679  
  13.680 @@ -2030,8 +2032,10 @@
  13.681  
  13.682    Using the following type classes, the testers generate values and convert
  13.683    them back into Isabelle terms for displaying counterexamples.
  13.684 +
  13.685      \begin{description}
  13.686 -    \item[@{text exhaustive}] The parameters of the type classes @{class exhaustive}
  13.687 +
  13.688 +    \<^descr>[@{text exhaustive}] The parameters of the type classes @{class exhaustive}
  13.689        and @{class full_exhaustive} implement the testing. They take a
  13.690        testing function as a parameter, which takes a value of type @{typ "'a"}
  13.691        and optionally produces a counterexample, and a size parameter for the test values.
  13.692 @@ -2043,13 +2047,13 @@
  13.693        testing function on all values up to the given size and stops as soon
  13.694        as a counterexample is found.
  13.695  
  13.696 -    \item[@{text random}] The operation @{const Quickcheck_Random.random}
  13.697 +    \<^descr>[@{text random}] The operation @{const Quickcheck_Random.random}
  13.698        of the type class @{class random} generates a pseudo-random
  13.699        value of the given size and a lazy term reconstruction of the value
  13.700        in the type @{typ Code_Evaluation.term}. A pseudo-randomness generator
  13.701        is defined in theory @{theory Random}.
  13.702  
  13.703 -    \item[@{text narrowing}] implements Haskell's Lazy Smallcheck @{cite "runciman-naylor-lindblad"}
  13.704 +    \<^descr>[@{text narrowing}] implements Haskell's Lazy Smallcheck @{cite "runciman-naylor-lindblad"}
  13.705        using the type classes @{class narrowing} and @{class partial_term_of}.
  13.706        Variables in the current goal are initially represented as symbolic variables.
  13.707        If the execution of the goal tries to evaluate one of them, the test engine
  13.708 @@ -2086,22 +2090,22 @@
  13.709        but it does not ensures consistency with @{const narrowing}.
  13.710      \end{description}
  13.711  
  13.712 -  \item @{command (HOL) "quickcheck_params"} changes @{command (HOL)
  13.713 +  \<^descr> @{command (HOL) "quickcheck_params"} changes @{command (HOL)
  13.714    "quickcheck"} configuration options persistently.
  13.715  
  13.716 -  \item @{command (HOL) "quickcheck_generator"} creates random and
  13.717 +  \<^descr> @{command (HOL) "quickcheck_generator"} creates random and
  13.718    exhaustive value generators for a given type and operations.  It
  13.719    generates values by using the operations as if they were
  13.720    constructors of that type.
  13.721  
  13.722 -  \item @{command (HOL) "nitpick"} tests the current goal for
  13.723 +  \<^descr> @{command (HOL) "nitpick"} tests the current goal for
  13.724    counterexamples using a reduction to first-order relational
  13.725    logic. See the Nitpick manual @{cite "isabelle-nitpick"} for details.
  13.726  
  13.727 -  \item @{command (HOL) "nitpick_params"} changes @{command (HOL)
  13.728 +  \<^descr> @{command (HOL) "nitpick_params"} changes @{command (HOL)
  13.729    "nitpick"} configuration options persistently.
  13.730  
  13.731 -  \item @{command (HOL) "find_unused_assms"} finds potentially superfluous
  13.732 +  \<^descr> @{command (HOL) "find_unused_assms"} finds potentially superfluous
  13.733    assumptions in theorems using quickcheck.
  13.734    It takes the theory name to be checked for superfluous assumptions as
  13.735    optional argument. If not provided, it checks the current theory.
  13.736 @@ -2140,18 +2144,18 @@
  13.737  
  13.738    \begin{description}
  13.739  
  13.740 -  \item @{attribute (HOL) "coercion"}~@{text "f"} registers a new
  13.741 +  \<^descr> @{attribute (HOL) "coercion"}~@{text "f"} registers a new
  13.742    coercion function @{text "f :: \<sigma>\<^sub>1 \<Rightarrow> \<sigma>\<^sub>2"} where @{text "\<sigma>\<^sub>1"} and
  13.743    @{text "\<sigma>\<^sub>2"} are type constructors without arguments.  Coercions are
  13.744    composed by the inference algorithm if needed.  Note that the type
  13.745    inference algorithm is complete only if the registered coercions
  13.746    form a lattice.
  13.747  
  13.748 -  \item @{attribute (HOL) "coercion_delete"}~@{text "f"} deletes a
  13.749 +  \<^descr> @{attribute (HOL) "coercion_delete"}~@{text "f"} deletes a
  13.750    preceding declaration (using @{attribute (HOL) "coercion"}) of the
  13.751    function @{text "f :: \<sigma>\<^sub>1 \<Rightarrow> \<sigma>\<^sub>2"} as a coercion.
  13.752  
  13.753 -  \item @{attribute (HOL) "coercion_map"}~@{text "map"} registers a
  13.754 +  \<^descr> @{attribute (HOL) "coercion_map"}~@{text "map"} registers a
  13.755    new map function to lift coercions through type constructors. The
  13.756    function @{text "map"} must conform to the following type pattern
  13.757  
  13.758 @@ -2165,7 +2169,7 @@
  13.759    overwrites any existing map function for this particular type
  13.760    constructor.
  13.761  
  13.762 -  \item @{attribute (HOL) "coercion_args"} can be used to disallow
  13.763 +  \<^descr> @{attribute (HOL) "coercion_args"} can be used to disallow
  13.764    coercions to be inserted in certain positions in a term. For example,
  13.765    given the constant @{text "c :: \<sigma>\<^sub>1 \<Rightarrow> \<sigma>\<^sub>2 \<Rightarrow> \<sigma>\<^sub>3 \<Rightarrow> \<sigma>\<^sub>4"} and the list
  13.766    of policies @{text "- + 0"} as arguments, coercions will not be
  13.767 @@ -2180,7 +2184,7 @@
  13.768    insertion of coercions (see, for example, the setup for the case syntax
  13.769    in @{theory Ctr_Sugar}). 
  13.770  
  13.771 -  \item @{attribute (HOL) "coercion_enabled"} enables the coercion
  13.772 +  \<^descr> @{attribute (HOL) "coercion_enabled"} enables the coercion
  13.773    inference algorithm.
  13.774  
  13.775    \end{description}
  13.776 @@ -2198,14 +2202,14 @@
  13.777  
  13.778    \begin{description}
  13.779  
  13.780 -  \item @{method (HOL) arith} decides linear arithmetic problems (on
  13.781 +  \<^descr> @{method (HOL) arith} decides linear arithmetic problems (on
  13.782    types @{text nat}, @{text int}, @{text real}).  Any current facts
  13.783    are inserted into the goal before running the procedure.
  13.784  
  13.785 -  \item @{attribute (HOL) arith} declares facts that are supplied to
  13.786 +  \<^descr> @{attribute (HOL) arith} declares facts that are supplied to
  13.787    the arithmetic provers implicitly.
  13.788  
  13.789 -  \item @{attribute (HOL) arith_split} attribute declares case split
  13.790 +  \<^descr> @{attribute (HOL) arith_split} attribute declares case split
  13.791    rules to be expanded before @{method (HOL) arith} is invoked.
  13.792  
  13.793    \end{description}
  13.794 @@ -2228,7 +2232,7 @@
  13.795  
  13.796    \begin{description}
  13.797  
  13.798 -  \item @{method (HOL) iprover} performs intuitionistic proof search,
  13.799 +  \<^descr> @{method (HOL) iprover} performs intuitionistic proof search,
  13.800    depending on specifically declared rules from the context, or given
  13.801    as explicit arguments.  Chained facts are inserted into the goal
  13.802    before commencing proof search.
  13.803 @@ -2264,11 +2268,11 @@
  13.804  
  13.805    \begin{description}
  13.806  
  13.807 -  \item @{method (HOL) meson} implements Loveland's model elimination
  13.808 +  \<^descr> @{method (HOL) meson} implements Loveland's model elimination
  13.809    procedure @{cite "loveland-78"}.  See @{file
  13.810    "~~/src/HOL/ex/Meson_Test.thy"} for examples.
  13.811  
  13.812 -  \item @{method (HOL) metis} combines ordered resolution and ordered
  13.813 +  \<^descr> @{method (HOL) metis} combines ordered resolution and ordered
  13.814    paramodulation to find first-order (or mildly higher-order) proofs.
  13.815    The first optional argument specifies a type encoding; see the
  13.816    Sledgehammer manual @{cite "isabelle-sledgehammer"} for details.  The
  13.817 @@ -2297,7 +2301,7 @@
  13.818  
  13.819    \begin{description}
  13.820  
  13.821 -  \item @{method (HOL) algebra} performs algebraic reasoning via
  13.822 +  \<^descr> @{method (HOL) algebra} performs algebraic reasoning via
  13.823    Gr\"obner bases, see also @{cite "Chaieb-Wenzel:2007"} and
  13.824    @{cite \<open>\S3.2\<close> "Chaieb-thesis"}. The method handles deals with two main
  13.825    classes of problems:
  13.826 @@ -2334,7 +2338,7 @@
  13.827    This acts like declarations for the Simplifier
  13.828    (\secref{sec:simplifier}) on a private simpset for this tool.
  13.829  
  13.830 -  \item @{attribute algebra} (as attribute) manages the default
  13.831 +  \<^descr> @{attribute algebra} (as attribute) manages the default
  13.832    collection of pre-simplification rules of the above proof method.
  13.833  
  13.834    \end{description}
  13.835 @@ -2378,7 +2382,7 @@
  13.836  
  13.837    \begin{description}
  13.838  
  13.839 -  \item @{method (HOL) coherent} solves problems of \emph{Coherent
  13.840 +  \<^descr> @{method (HOL) coherent} solves problems of \emph{Coherent
  13.841    Logic} @{cite "Bezem-Coquand:2005"}, which covers applications in
  13.842    confluence theory, lattice theory and projective geometry.  See
  13.843    @{file "~~/src/HOL/ex/Coherent.thy"} for some examples.
  13.844 @@ -2415,7 +2419,7 @@
  13.845  
  13.846    \begin{description}
  13.847  
  13.848 -  \item @{method (HOL) case_tac} and @{method (HOL) induct_tac} admit
  13.849 +  \<^descr> @{method (HOL) case_tac} and @{method (HOL) induct_tac} admit
  13.850    to reason about inductive types.  Rules are selected according to
  13.851    the declarations by the @{attribute cases} and @{attribute induct}
  13.852    attributes, cf.\ \secref{sec:cases-induct}.  The @{command (HOL)
  13.853 @@ -2429,7 +2433,7 @@
  13.854    statements, only the compact object-logic conclusion of the subgoal
  13.855    being addressed.
  13.856  
  13.857 -  \item @{method (HOL) ind_cases} and @{command (HOL)
  13.858 +  \<^descr> @{method (HOL) ind_cases} and @{command (HOL)
  13.859    "inductive_cases"} provide an interface to the internal @{ML_text
  13.860    mk_cases} operation.  Rules are simplified in an unrestricted
  13.861    forward manner.
  13.862 @@ -2459,7 +2463,7 @@
  13.863  
  13.864    \begin{description}
  13.865  
  13.866 -  \item @{attribute (HOL) split_format}\ @{text "(complete)"} causes
  13.867 +  \<^descr> @{attribute (HOL) split_format}\ @{text "(complete)"} causes
  13.868    arguments in function applications to be represented canonically
  13.869    according to their tuple type structure.
  13.870  
  13.871 @@ -2599,7 +2603,7 @@
  13.872  
  13.873    \begin{description}
  13.874  
  13.875 -  \item @{command (HOL) "export_code"} generates code for a given list of
  13.876 +  \<^descr> @{command (HOL) "export_code"} generates code for a given list of
  13.877    constants in the specified target language(s). If no serialization
  13.878    instruction is given, only abstract code is generated internally.
  13.879  
  13.880 @@ -2627,7 +2631,7 @@
  13.881    "deriving (Read, Show)"}'' clause to each appropriate datatype
  13.882    declaration.
  13.883  
  13.884 -  \item @{attribute (HOL) code} declare code equations for code generation.
  13.885 +  \<^descr> @{attribute (HOL) code} declare code equations for code generation.
  13.886    Variant @{text "code equation"} declares a conventional equation as code
  13.887    equation. Variants @{text "code abstype"} and @{text "code abstract"}
  13.888    declare abstract datatype certificates or code equations on abstract
  13.889 @@ -2645,49 +2649,49 @@
  13.890    Usually packages introducing code equations provide a reasonable default
  13.891    setup for selection.
  13.892  
  13.893 -  \item @{command (HOL) "code_datatype"} specifies a constructor set for a
  13.894 +  \<^descr> @{command (HOL) "code_datatype"} specifies a constructor set for a
  13.895    logical type.
  13.896  
  13.897 -  \item @{command (HOL) "print_codesetup"} gives an overview on selected
  13.898 +  \<^descr> @{command (HOL) "print_codesetup"} gives an overview on selected
  13.899    code equations and code generator datatypes.
  13.900  
  13.901 -  \item @{attribute (HOL) code_unfold} declares (or with option ``@{text
  13.902 +  \<^descr> @{attribute (HOL) code_unfold} declares (or with option ``@{text
  13.903    "del"}'' removes) theorems which during preprocessing are applied as
  13.904    rewrite rules to any code equation or evaluation input.
  13.905  
  13.906 -  \item @{attribute (HOL) code_post} declares (or with option ``@{text
  13.907 +  \<^descr> @{attribute (HOL) code_post} declares (or with option ``@{text
  13.908    "del"}'' removes) theorems which are applied as rewrite rules to any
  13.909    result of an evaluation.
  13.910  
  13.911 -  \item @{attribute (HOL) code_abbrev} declares (or with option ``@{text
  13.912 +  \<^descr> @{attribute (HOL) code_abbrev} declares (or with option ``@{text
  13.913    "del"}'' removes) equations which are applied as rewrite rules to any
  13.914    result of an evaluation and symmetrically during preprocessing to any code
  13.915    equation or evaluation input.
  13.916  
  13.917 -  \item @{command (HOL) "print_codeproc"} prints the setup of the code
  13.918 +  \<^descr> @{command (HOL) "print_codeproc"} prints the setup of the code
  13.919    generator preprocessor.
  13.920  
  13.921 -  \item @{command (HOL) "code_thms"} prints a list of theorems representing
  13.922 +  \<^descr> @{command (HOL) "code_thms"} prints a list of theorems representing
  13.923    the corresponding program containing all given constants after
  13.924    preprocessing.
  13.925  
  13.926 -  \item @{command (HOL) "code_deps"} visualizes dependencies of theorems
  13.927 +  \<^descr> @{command (HOL) "code_deps"} visualizes dependencies of theorems
  13.928    representing the corresponding program containing all given constants
  13.929    after preprocessing.
  13.930  
  13.931 -  \item @{command (HOL) "code_reserved"} declares a list of names as
  13.932 +  \<^descr> @{command (HOL) "code_reserved"} declares a list of names as
  13.933    reserved for a given target, preventing it to be shadowed by any generated
  13.934    code.
  13.935  
  13.936 -  \item @{command (HOL) "code_printing"} associates a series of symbols
  13.937 +  \<^descr> @{command (HOL) "code_printing"} associates a series of symbols
  13.938    (constants, type constructors, classes, class relations, instances, module
  13.939    names) with target-specific serializations; omitting a serialization
  13.940    deletes an existing serialization.
  13.941  
  13.942 -  \item @{command (HOL) "code_monad"} provides an auxiliary mechanism to
  13.943 +  \<^descr> @{command (HOL) "code_monad"} provides an auxiliary mechanism to
  13.944    generate monadic code for Haskell.
  13.945  
  13.946 -  \item @{command (HOL) "code_identifier"} associates a a series of symbols
  13.947 +  \<^descr> @{command (HOL) "code_identifier"} associates a a series of symbols
  13.948    (constants, type constructors, classes, class relations, instances, module
  13.949    names) with target-specific hints how these symbols shall be named. These
  13.950    hints gain precedence over names for symbols with no hints at all.
  13.951 @@ -2696,7 +2700,7 @@
  13.952    identifiers in compound statements like type classes or datatypes are
  13.953    still the same.
  13.954  
  13.955 -  \item @{command (HOL) "code_reflect"} without a ``@{text "file"}''
  13.956 +  \<^descr> @{command (HOL) "code_reflect"} without a ``@{text "file"}''
  13.957    argument compiles code into the system runtime environment and modifies
  13.958    the code generator setup that future invocations of system runtime code
  13.959    generation referring to one of the ``@{text "datatypes"}'' or ``@{text
  13.960 @@ -2704,7 +2708,7 @@
  13.961    "file"}'' argument, the corresponding code is generated into that
  13.962    specified file without modifying the code generator setup.
  13.963  
  13.964 -  \item @{command (HOL) "code_pred"} creates code equations for a predicate
  13.965 +  \<^descr> @{command (HOL) "code_pred"} creates code equations for a predicate
  13.966    given a set of introduction rules. Optional mode annotations determine
  13.967    which arguments are supposed to be input or output. If alternative
  13.968    introduction rules are declared, one must prove a corresponding
    14.1 --- a/src/Doc/Isar_Ref/Inner_Syntax.thy	Wed Oct 14 15:06:42 2015 +0200
    14.2 +++ b/src/Doc/Isar_Ref/Inner_Syntax.thy	Wed Oct 14 15:10:32 2015 +0200
    14.3 @@ -64,41 +64,41 @@
    14.4  
    14.5    \begin{description}
    14.6  
    14.7 -  \item @{command "typ"}~@{text \<tau>} reads and prints a type expression
    14.8 +  \<^descr> @{command "typ"}~@{text \<tau>} reads and prints a type expression
    14.9    according to the current context.
   14.10  
   14.11 -  \item @{command "typ"}~@{text "\<tau> :: s"} uses type-inference to
   14.12 +  \<^descr> @{command "typ"}~@{text "\<tau> :: s"} uses type-inference to
   14.13    determine the most general way to make @{text "\<tau>"} conform to sort
   14.14    @{text "s"}.  For concrete @{text "\<tau>"} this checks if the type
   14.15    belongs to that sort.  Dummy type parameters ``@{text "_"}''
   14.16    (underscore) are assigned to fresh type variables with most general
   14.17    sorts, according the the principles of type-inference.
   14.18  
   14.19 -  \item @{command "term"}~@{text t} and @{command "prop"}~@{text \<phi>}
   14.20 +  \<^descr> @{command "term"}~@{text t} and @{command "prop"}~@{text \<phi>}
   14.21    read, type-check and print terms or propositions according to the
   14.22    current theory or proof context; the inferred type of @{text t} is
   14.23    output as well.  Note that these commands are also useful in
   14.24    inspecting the current environment of term abbreviations.
   14.25  
   14.26 -  \item @{command "thm"}~@{text "a\<^sub>1 \<dots> a\<^sub>n"} retrieves
   14.27 +  \<^descr> @{command "thm"}~@{text "a\<^sub>1 \<dots> a\<^sub>n"} retrieves
   14.28    theorems from the current theory or proof context.  Note that any
   14.29    attributes included in the theorem specifications are applied to a
   14.30    temporary context derived from the current theory or proof; the
   14.31    result is discarded, i.e.\ attributes involved in @{text "a\<^sub>1,
   14.32    \<dots>, a\<^sub>n"} do not have any permanent effect.
   14.33  
   14.34 -  \item @{command "prf"} displays the (compact) proof term of the
   14.35 +  \<^descr> @{command "prf"} displays the (compact) proof term of the
   14.36    current proof state (if present), or of the given theorems. Note
   14.37    that this requires proof terms to be switched on for the current
   14.38    object logic (see the ``Proof terms'' section of the Isabelle
   14.39    reference manual for information on how to do this).
   14.40  
   14.41 -  \item @{command "full_prf"} is like @{command "prf"}, but displays
   14.42 +  \<^descr> @{command "full_prf"} is like @{command "prf"}, but displays
   14.43    the full proof term, i.e.\ also displays information omitted in the
   14.44    compact proof term, which is denoted by ``@{text _}'' placeholders
   14.45    there.
   14.46  
   14.47 -  \item @{command "print_state"} prints the current proof state (if
   14.48 +  \<^descr> @{command "print_state"} prints the current proof state (if
   14.49    present), including current facts and goals.
   14.50  
   14.51    \end{description}
   14.52 @@ -146,14 +146,14 @@
   14.53  
   14.54    \begin{description}
   14.55  
   14.56 -  \item @{attribute show_markup} controls direct inlining of markup
   14.57 +  \<^descr> @{attribute show_markup} controls direct inlining of markup
   14.58    into the printed representation of formal entities --- notably type
   14.59    and sort constraints.  This enables Prover IDE users to retrieve
   14.60    that information via tooltips or popups while hovering with the
   14.61    mouse over the output window, for example.  Consequently, this
   14.62    option is enabled by default for Isabelle/jEdit.
   14.63  
   14.64 -  \item @{attribute show_types} and @{attribute show_sorts} control
   14.65 +  \<^descr> @{attribute show_types} and @{attribute show_sorts} control
   14.66    printing of type constraints for term variables, and sort
   14.67    constraints for type variables.  By default, neither of these are
   14.68    shown in output.  If @{attribute show_sorts} is enabled, types are
   14.69 @@ -165,29 +165,29 @@
   14.70    inference rule fails to resolve with some goal, or why a rewrite
   14.71    rule does not apply as expected.
   14.72  
   14.73 -  \item @{attribute show_consts} controls printing of types of
   14.74 +  \<^descr> @{attribute show_consts} controls printing of types of
   14.75    constants when displaying a goal state.
   14.76  
   14.77    Note that the output can be enormous, because polymorphic constants
   14.78    often occur at several different type instances.
   14.79  
   14.80 -  \item @{attribute show_abbrevs} controls folding of constant
   14.81 +  \<^descr> @{attribute show_abbrevs} controls folding of constant
   14.82    abbreviations.
   14.83  
   14.84 -  \item @{attribute show_brackets} controls bracketing in pretty
   14.85 +  \<^descr> @{attribute show_brackets} controls bracketing in pretty
   14.86    printed output.  If enabled, all sub-expressions of the pretty
   14.87    printing tree will be parenthesized, even if this produces malformed
   14.88    term syntax!  This crude way of showing the internal structure of
   14.89    pretty printed entities may occasionally help to diagnose problems
   14.90    with operator priorities, for example.
   14.91  
   14.92 -  \item @{attribute names_long}, @{attribute names_short}, and
   14.93 +  \<^descr> @{attribute names_long}, @{attribute names_short}, and
   14.94    @{attribute names_unique} control the way of printing fully
   14.95    qualified internal names in external form.  See also
   14.96    \secref{sec:antiq} for the document antiquotation options of the
   14.97    same names.
   14.98  
   14.99 -  \item @{attribute eta_contract} controls @{text "\<eta>"}-contracted
  14.100 +  \<^descr> @{attribute eta_contract} controls @{text "\<eta>"}-contracted
  14.101    printing of terms.
  14.102  
  14.103    The @{text \<eta>}-contraction law asserts @{prop "(\<lambda>x. f x) \<equiv> f"},
  14.104 @@ -207,15 +207,15 @@
  14.105    rewriting operate modulo @{text "\<alpha>\<beta>\<eta>"}-conversion, some other tools
  14.106    might look at terms more discretely.
  14.107  
  14.108 -  \item @{attribute goals_limit} controls the maximum number of
  14.109 +  \<^descr> @{attribute goals_limit} controls the maximum number of
  14.110    subgoals to be printed.
  14.111  
  14.112 -  \item @{attribute show_main_goal} controls whether the main result
  14.113 +  \<^descr> @{attribute show_main_goal} controls whether the main result
  14.114    to be proven should be displayed.  This information might be
  14.115    relevant for schematic goals, to inspect the current claim that has
  14.116    been synthesized so far.
  14.117  
  14.118 -  \item @{attribute show_hyps} controls printing of implicit
  14.119 +  \<^descr> @{attribute show_hyps} controls printing of implicit
  14.120    hypotheses of local facts.  Normally, only those hypotheses are
  14.121    displayed that are \emph{not} covered by the assumptions of the
  14.122    current context: this situation indicates a fault in some tool being
  14.123 @@ -225,7 +225,7 @@
  14.124    can be enforced, which is occasionally useful for diagnostic
  14.125    purposes.
  14.126  
  14.127 -  \item @{attribute show_tags} controls printing of extra annotations
  14.128 +  \<^descr> @{attribute show_tags} controls printing of extra annotations
  14.129    within theorems, such as internal position information, or the case
  14.130    names being attached by the attribute @{attribute case_names}.
  14.131  
  14.132 @@ -233,7 +233,7 @@
  14.133    attributes provide low-level access to the collection of tags
  14.134    associated with a theorem.
  14.135  
  14.136 -  \item @{attribute show_question_marks} controls printing of question
  14.137 +  \<^descr> @{attribute show_question_marks} controls printing of question
  14.138    marks for schematic variables, such as @{text ?x}.  Only the leading
  14.139    question mark is affected, the remaining text is unchanged
  14.140    (including proper markup for schematic variables that might be
  14.141 @@ -259,12 +259,12 @@
  14.142  
  14.143    \begin{description}
  14.144  
  14.145 -  \item @{ML "print_mode_value ()"} yields the list of currently
  14.146 +  \<^descr> @{ML "print_mode_value ()"} yields the list of currently
  14.147    active print mode names.  This should be understood as symbolic
  14.148    representation of certain individual features for printing (with
  14.149    precedence from left to right).
  14.150  
  14.151 -  \item @{ML Print_Mode.with_modes}~@{text "modes f x"} evaluates
  14.152 +  \<^descr> @{ML Print_Mode.with_modes}~@{text "modes f x"} evaluates
  14.153    @{text "f x"} in an execution context where the print mode is
  14.154    prepended by the given @{text "modes"}.  This provides a thread-safe
  14.155    way to augment print modes.  It is also monotonic in the set of mode
  14.156 @@ -379,7 +379,7 @@
  14.157  
  14.158    \begin{description}
  14.159  
  14.160 -  \item @{text "d"} is a delimiter, namely a non-empty sequence of
  14.161 +  \<^descr> @{text "d"} is a delimiter, namely a non-empty sequence of
  14.162    characters other than the following special characters:
  14.163  
  14.164    \<^medskip>
  14.165 @@ -393,7 +393,7 @@
  14.166    \end{tabular}
  14.167    \<^medskip>
  14.168  
  14.169 -  \item @{verbatim "'"} escapes the special meaning of these
  14.170 +  \<^descr> @{verbatim "'"} escapes the special meaning of these
  14.171    meta-characters, producing a literal version of the following
  14.172    character, unless that is a blank.
  14.173  
  14.174 @@ -401,26 +401,26 @@
  14.175    affecting printing, but input tokens may have additional white space
  14.176    here.
  14.177  
  14.178 -  \item @{verbatim "_"} is an argument position, which stands for a
  14.179 +  \<^descr> @{verbatim "_"} is an argument position, which stands for a
  14.180    certain syntactic category in the underlying grammar.
  14.181  
  14.182 -  \item @{text "\<index>"} is an indexed argument position; this is the place
  14.183 +  \<^descr> @{text "\<index>"} is an indexed argument position; this is the place
  14.184    where implicit structure arguments can be attached.
  14.185  
  14.186 -  \item @{text "s"} is a non-empty sequence of spaces for printing.
  14.187 +  \<^descr> @{text "s"} is a non-empty sequence of spaces for printing.
  14.188    This and the following specifications do not affect parsing at all.
  14.189  
  14.190 -  \item @{verbatim "("}@{text n} opens a pretty printing block.  The
  14.191 +  \<^descr> @{verbatim "("}@{text n} opens a pretty printing block.  The
  14.192    optional number specifies how much indentation to add when a line
  14.193    break occurs within the block.  If the parenthesis is not followed
  14.194    by digits, the indentation defaults to 0.  A block specified via
  14.195    @{verbatim "(00"} is unbreakable.
  14.196  
  14.197 -  \item @{verbatim ")"} closes a pretty printing block.
  14.198 +  \<^descr> @{verbatim ")"} closes a pretty printing block.
  14.199  
  14.200 -  \item @{verbatim "//"} forces a line break.
  14.201 +  \<^descr> @{verbatim "//"} forces a line break.
  14.202  
  14.203 -  \item @{verbatim "/"}@{text s} allows a line break.  Here @{text s}
  14.204 +  \<^descr> @{verbatim "/"}@{text s} allows a line break.  Here @{text s}
  14.205    stands for the string of spaces (zero or more) right after the
  14.206    slash.  These spaces are printed if the break is \emph{not} taken.
  14.207  
  14.208 @@ -534,23 +534,23 @@
  14.209  
  14.210    \begin{description}
  14.211  
  14.212 -  \item @{command "type_notation"}~@{text "c (mx)"} associates mixfix
  14.213 +  \<^descr> @{command "type_notation"}~@{text "c (mx)"} associates mixfix
  14.214    syntax with an existing type constructor.  The arity of the
  14.215    constructor is retrieved from the context.
  14.216  
  14.217 -  \item @{command "no_type_notation"} is similar to @{command
  14.218 +  \<^descr> @{command "no_type_notation"} is similar to @{command
  14.219    "type_notation"}, but removes the specified syntax annotation from
  14.220    the present context.
  14.221  
  14.222 -  \item @{command "notation"}~@{text "c (mx)"} associates mixfix
  14.223 +  \<^descr> @{command "notation"}~@{text "c (mx)"} associates mixfix
  14.224    syntax with an existing constant or fixed variable.  The type
  14.225    declaration of the given entity is retrieved from the context.
  14.226  
  14.227 -  \item @{command "no_notation"} is similar to @{command "notation"},
  14.228 +  \<^descr> @{command "no_notation"} is similar to @{command "notation"},
  14.229    but removes the specified syntax annotation from the present
  14.230    context.
  14.231  
  14.232 -  \item @{command "write"} is similar to @{command "notation"}, but
  14.233 +  \<^descr> @{command "write"} is similar to @{command "notation"}, but
  14.234    works within an Isar proof body.
  14.235  
  14.236    \end{description}
  14.237 @@ -773,15 +773,15 @@
  14.238  
  14.239    \begin{description}
  14.240  
  14.241 -  \item @{syntax_ref (inner) any} denotes any term.
  14.242 +  \<^descr> @{syntax_ref (inner) any} denotes any term.
  14.243  
  14.244 -  \item @{syntax_ref (inner) prop} denotes meta-level propositions,
  14.245 +  \<^descr> @{syntax_ref (inner) prop} denotes meta-level propositions,
  14.246    which are terms of type @{typ prop}.  The syntax of such formulae of
  14.247    the meta-logic is carefully distinguished from usual conventions for
  14.248    object-logics.  In particular, plain @{text "\<lambda>"}-term notation is
  14.249    \emph{not} recognized as @{syntax (inner) prop}.
  14.250  
  14.251 -  \item @{syntax_ref (inner) aprop} denotes atomic propositions, which
  14.252 +  \<^descr> @{syntax_ref (inner) aprop} denotes atomic propositions, which
  14.253    are embedded into regular @{syntax (inner) prop} by means of an
  14.254    explicit @{verbatim PROP} token.
  14.255  
  14.256 @@ -791,7 +791,7 @@
  14.257    the printed version will appear like @{syntax (inner) logic} and
  14.258    cannot be parsed again as @{syntax (inner) prop}.
  14.259  
  14.260 -  \item @{syntax_ref (inner) logic} denotes arbitrary terms of a
  14.261 +  \<^descr> @{syntax_ref (inner) logic} denotes arbitrary terms of a
  14.262    logical type, excluding type @{typ prop}.  This is the main
  14.263    syntactic category of object-logic entities, covering plain @{text
  14.264    \<lambda>}-term notation (variables, abstraction, application), plus
  14.265 @@ -801,28 +801,28 @@
  14.266    (excluding @{typ prop}) are \emph{collapsed} to this single category
  14.267    of @{syntax (inner) logic}.
  14.268  
  14.269 -  \item @{syntax_ref (inner) index} denotes an optional index term for
  14.270 +  \<^descr> @{syntax_ref (inner) index} denotes an optional index term for
  14.271    indexed syntax.  If omitted, it refers to the first @{keyword_ref
  14.272    "structure"} variable in the context.  The special dummy ``@{text
  14.273    "\<index>"}'' serves as pattern variable in mixfix annotations that
  14.274    introduce indexed notation.
  14.275  
  14.276 -  \item @{syntax_ref (inner) idt} denotes identifiers, possibly
  14.277 +  \<^descr> @{syntax_ref (inner) idt} denotes identifiers, possibly
  14.278    constrained by types.
  14.279  
  14.280 -  \item @{syntax_ref (inner) idts} denotes a sequence of @{syntax_ref
  14.281 +  \<^descr> @{syntax_ref (inner) idts} denotes a sequence of @{syntax_ref
  14.282    (inner) idt}.  This is the most basic category for variables in
  14.283    iterated binders, such as @{text "\<lambda>"} or @{text "\<And>"}.
  14.284  
  14.285 -  \item @{syntax_ref (inner) pttrn} and @{syntax_ref (inner) pttrns}
  14.286 +  \<^descr> @{syntax_ref (inner) pttrn} and @{syntax_ref (inner) pttrns}
  14.287    denote patterns for abstraction, cases bindings etc.  In Pure, these
  14.288    categories start as a merely copy of @{syntax (inner) idt} and
  14.289    @{syntax (inner) idts}, respectively.  Object-logics may add
  14.290    additional productions for binding forms.
  14.291  
  14.292 -  \item @{syntax_ref (inner) type} denotes types of the meta-logic.
  14.293 +  \<^descr> @{syntax_ref (inner) type} denotes types of the meta-logic.
  14.294  
  14.295 -  \item @{syntax_ref (inner) sort} denotes meta-level sorts.
  14.296 +  \<^descr> @{syntax_ref (inner) sort} denotes meta-level sorts.
  14.297  
  14.298    \end{description}
  14.299  
  14.300 @@ -851,20 +851,20 @@
  14.301  
  14.302    \begin{description}
  14.303  
  14.304 -  \item A type ``@{text "_"}'' or ``@{text "_ :: sort"}'' acts like an
  14.305 +  \<^descr> A type ``@{text "_"}'' or ``@{text "_ :: sort"}'' acts like an
  14.306    anonymous inference parameter, which is filled-in according to the
  14.307    most general type produced by the type-checking phase.
  14.308  
  14.309 -  \item A bound ``@{text "_"}'' refers to a vacuous abstraction, where
  14.310 +  \<^descr> A bound ``@{text "_"}'' refers to a vacuous abstraction, where
  14.311    the body does not refer to the binding introduced here.  As in the
  14.312    term @{term "\<lambda>x _. x"}, which is @{text "\<alpha>"}-equivalent to @{text
  14.313    "\<lambda>x y. x"}.
  14.314  
  14.315 -  \item A free ``@{text "_"}'' refers to an implicit outer binding.
  14.316 +  \<^descr> A free ``@{text "_"}'' refers to an implicit outer binding.
  14.317    Higher definitional packages usually allow forms like @{text "f x _
  14.318    = x"}.
  14.319  
  14.320 -  \item A schematic ``@{text "_"}'' (within a term pattern, see
  14.321 +  \<^descr> A schematic ``@{text "_"}'' (within a term pattern, see
  14.322    \secref{sec:term-decls}) refers to an anonymous variable that is
  14.323    implicitly abstracted over its context of locally bound variables.
  14.324    For example, this allows pattern matching of @{text "{x. f x = g
  14.325 @@ -873,18 +873,18 @@
  14.326  
  14.327    \end{description}
  14.328  
  14.329 -  \item The three literal dots ``@{verbatim "..."}'' may be also
  14.330 +  \<^descr> The three literal dots ``@{verbatim "..."}'' may be also
  14.331    written as ellipsis symbol @{verbatim "\<dots>"}.  In both cases this
  14.332    refers to a special schematic variable, which is bound in the
  14.333    context.  This special term abbreviation works nicely with
  14.334    calculational reasoning (\secref{sec:calculation}).
  14.335  
  14.336 -  \item @{verbatim CONST} ensures that the given identifier is treated
  14.337 +  \<^descr> @{verbatim CONST} ensures that the given identifier is treated
  14.338    as constant term, and passed through the parse tree in fully
  14.339    internalized form.  This is particularly relevant for translation
  14.340    rules (\secref{sec:syn-trans}), notably on the RHS.
  14.341  
  14.342 -  \item @{verbatim XCONST} is similar to @{verbatim CONST}, but
  14.343 +  \<^descr> @{verbatim XCONST} is similar to @{verbatim CONST}, but
  14.344    retains the constant name as given.  This is only relevant to
  14.345    translation rules (\secref{sec:syn-trans}), notably on the LHS.
  14.346  
  14.347 @@ -901,16 +901,16 @@
  14.348  
  14.349    \begin{description}
  14.350  
  14.351 -  \item @{command "print_syntax"} prints the inner syntax of the
  14.352 +  \<^descr> @{command "print_syntax"} prints the inner syntax of the
  14.353    current context.  The output can be quite large; the most important
  14.354    sections are explained below.
  14.355  
  14.356    \begin{description}
  14.357  
  14.358 -  \item @{text "lexicon"} lists the delimiters of the inner token
  14.359 +  \<^descr> @{text "lexicon"} lists the delimiters of the inner token
  14.360    language; see \secref{sec:inner-lex}.
  14.361  
  14.362 -  \item @{text "prods"} lists the productions of the underlying
  14.363 +  \<^descr> @{text "prods"} lists the productions of the underlying
  14.364    priority grammar; see \secref{sec:priority-grammar}.
  14.365  
  14.366    The nonterminal @{text "A\<^sup>(\<^sup>p\<^sup>)"} is rendered in plain text as @{text
  14.367 @@ -931,18 +931,18 @@
  14.368    Priority information attached to chain productions is ignored; only
  14.369    the dummy value @{text "-1"} is displayed.
  14.370  
  14.371 -  \item @{text "print modes"} lists the alternative print modes
  14.372 +  \<^descr> @{text "print modes"} lists the alternative print modes
  14.373    provided by this grammar; see \secref{sec:print-modes}.
  14.374  
  14.375 -  \item @{text "parse_rules"} and @{text "print_rules"} relate to
  14.376 +  \<^descr> @{text "parse_rules"} and @{text "print_rules"} relate to
  14.377    syntax translations (macros); see \secref{sec:syn-trans}.
  14.378  
  14.379 -  \item @{text "parse_ast_translation"} and @{text
  14.380 +  \<^descr> @{text "parse_ast_translation"} and @{text
  14.381    "print_ast_translation"} list sets of constants that invoke
  14.382    translation functions for abstract syntax trees, which are only
  14.383    required in very special situations; see \secref{sec:tr-funs}.
  14.384  
  14.385 -  \item @{text "parse_translation"} and @{text "print_translation"}
  14.386 +  \<^descr> @{text "parse_translation"} and @{text "print_translation"}
  14.387    list the sets of constants that invoke regular translation
  14.388    functions; see \secref{sec:tr-funs}.
  14.389  
  14.390 @@ -976,10 +976,10 @@
  14.391  
  14.392    \begin{description}
  14.393  
  14.394 -  \item @{attribute syntax_ambiguity_warning} controls output of
  14.395 +  \<^descr> @{attribute syntax_ambiguity_warning} controls output of
  14.396    explicit warning messages about syntax ambiguity.
  14.397  
  14.398 -  \item @{attribute syntax_ambiguity_limit} determines the number of
  14.399 +  \<^descr> @{attribute syntax_ambiguity_limit} determines the number of
  14.400    resulting parse trees that are shown as part of the printed message
  14.401    in case of an ambiguity.
  14.402  
  14.403 @@ -1197,11 +1197,11 @@
  14.404  
  14.405    \begin{description}
  14.406  
  14.407 -  \item @{command "nonterminal"}~@{text c} declares a type
  14.408 +  \<^descr> @{command "nonterminal"}~@{text c} declares a type
  14.409    constructor @{text c} (without arguments) to act as purely syntactic
  14.410    type: a nonterminal symbol of the inner syntax.
  14.411  
  14.412 -  \item @{command "syntax"}~@{text "(mode) c :: \<sigma> (mx)"} augments the
  14.413 +  \<^descr> @{command "syntax"}~@{text "(mode) c :: \<sigma> (mx)"} augments the
  14.414    priority grammar and the pretty printer table for the given print
  14.415    mode (default @{verbatim \<open>""\<close>}). An optional keyword @{keyword_ref
  14.416    "output"} means that only the pretty printer table is affected.
  14.417 @@ -1251,11 +1251,11 @@
  14.418    resulting parse tree @{text "t"} is copied directly, without any
  14.419    further decoration.
  14.420  
  14.421 -  \item @{command "no_syntax"}~@{text "(mode) decls"} removes grammar
  14.422 +  \<^descr> @{command "no_syntax"}~@{text "(mode) decls"} removes grammar
  14.423    declarations (and translations) resulting from @{text decls}, which
  14.424    are interpreted in the same manner as for @{command "syntax"} above.
  14.425  
  14.426 -  \item @{command "translations"}~@{text rules} specifies syntactic
  14.427 +  \<^descr> @{command "translations"}~@{text rules} specifies syntactic
  14.428    translation rules (i.e.\ macros) as first-order rewrite rules on
  14.429    ASTs (\secref{sec:ast}).  The theory context maintains two
  14.430    independent lists translation rules: parse rules (@{verbatim "=>"}
  14.431 @@ -1302,11 +1302,11 @@
  14.432  
  14.433    \end{itemize}
  14.434  
  14.435 -  \item @{command "no_translations"}~@{text rules} removes syntactic
  14.436 +  \<^descr> @{command "no_translations"}~@{text rules} removes syntactic
  14.437    translation rules, which are interpreted in the same manner as for
  14.438    @{command "translations"} above.
  14.439  
  14.440 -  \item @{attribute syntax_ast_trace} and @{attribute
  14.441 +  \<^descr> @{attribute syntax_ast_trace} and @{attribute
  14.442    syntax_ast_stats} control diagnostic output in the AST normalization
  14.443    process, when translation rules are applied to concrete input or
  14.444    output.
  14.445 @@ -1441,7 +1441,7 @@
  14.446  
  14.447    \begin{description}
  14.448  
  14.449 -  \item @{command parse_translation} etc. declare syntax translation
  14.450 +  \<^descr> @{command parse_translation} etc. declare syntax translation
  14.451    functions to the theory.  Any of these commands have a single
  14.452    @{syntax text} argument that refers to an ML expression of
  14.453    appropriate type as follows:
  14.454 @@ -1473,14 +1473,14 @@
  14.455    associated with the translation functions of a theory under @{text
  14.456    "parse_ast_translation"} etc.
  14.457  
  14.458 -  \item @{text "@{class_syntax c}"}, @{text "@{type_syntax c}"},
  14.459 +  \<^descr> @{text "@{class_syntax c}"}, @{text "@{type_syntax c}"},
  14.460    @{text "@{const_syntax c}"} inline the authentic syntax name of the
  14.461    given formal entities into the ML source.  This is the
  14.462    fully-qualified logical name prefixed by a special marker to
  14.463    indicate its kind: thus different logical name spaces are properly
  14.464    distinguished within parse trees.
  14.465  
  14.466 -  \item @{text "@{const_syntax c}"} inlines the name @{text "c"} of
  14.467 +  \<^descr> @{text "@{const_syntax c}"} inlines the name @{text "c"} of
  14.468    the given syntax constant, having checked that it has been declared
  14.469    via some @{command syntax} commands within the theory context.  Note
  14.470    that the usual naming convention makes syntax constants start with
  14.471 @@ -1517,12 +1517,12 @@
  14.472  
  14.473    \begin{description}
  14.474  
  14.475 -  \item [Parse translations] are applied bottom-up.  The arguments are
  14.476 +  \<^descr>[Parse translations] are applied bottom-up.  The arguments are
  14.477    already in translated form.  The translations must not fail;
  14.478    exceptions trigger an error message.  There may be at most one
  14.479    function associated with any syntactic name.
  14.480  
  14.481 -  \item [Print translations] are applied top-down.  They are supplied
  14.482 +  \<^descr>[Print translations] are applied top-down.  They are supplied
  14.483    with arguments that are partly still in internal form.  The result
  14.484    again undergoes translation; therefore a print translation should
  14.485    not introduce as head the very constant that invoked it.  The
    15.1 --- a/src/Doc/Isar_Ref/Outer_Syntax.thy	Wed Oct 14 15:06:42 2015 +0200
    15.2 +++ b/src/Doc/Isar_Ref/Outer_Syntax.thy	Wed Oct 14 15:10:32 2015 +0200
    15.3 @@ -49,10 +49,10 @@
    15.4  
    15.5    \begin{description}
    15.6  
    15.7 -  \item @{command "print_commands"} prints all outer syntax keywords
    15.8 +  \<^descr> @{command "print_commands"} prints all outer syntax keywords
    15.9    and commands.
   15.10  
   15.11 -  \item @{command "help"}~@{text "pats"} retrieves outer syntax
   15.12 +  \<^descr> @{command "help"}~@{text "pats"} retrieves outer syntax
   15.13    commands according to the specified name patterns.
   15.14  
   15.15    \end{description}
   15.16 @@ -505,35 +505,35 @@
   15.17  
   15.18    \begin{description}
   15.19  
   15.20 -  \item @{command "print_theory"} prints the main logical content of the
   15.21 +  \<^descr> @{command "print_theory"} prints the main logical content of the
   15.22    background theory; the ``@{text "!"}'' option indicates extra verbosity.
   15.23  
   15.24 -  \item @{command "print_definitions"} prints dependencies of definitional
   15.25 +  \<^descr> @{command "print_definitions"} prints dependencies of definitional
   15.26    specifications within the background theory, which may be constants
   15.27    \secref{sec:consts} or types (\secref{sec:types-pure},
   15.28    \secref{sec:hol-typedef}); the ``@{text "!"}'' option indicates extra
   15.29    verbosity.
   15.30  
   15.31 -  \item @{command "print_methods"} prints all proof methods available in the
   15.32 +  \<^descr> @{command "print_methods"} prints all proof methods available in the
   15.33    current theory context; the ``@{text "!"}'' option indicates extra
   15.34    verbosity.
   15.35  
   15.36 -  \item @{command "print_attributes"} prints all attributes available in the
   15.37 +  \<^descr> @{command "print_attributes"} prints all attributes available in the
   15.38    current theory context; the ``@{text "!"}'' option indicates extra
   15.39    verbosity.
   15.40  
   15.41 -  \item @{command "print_theorems"} prints theorems of the background theory
   15.42 +  \<^descr> @{command "print_theorems"} prints theorems of the background theory
   15.43    resulting from the last command; the ``@{text "!"}'' option indicates
   15.44    extra verbosity.
   15.45  
   15.46 -  \item @{command "print_facts"} prints all local facts of the current
   15.47 +  \<^descr> @{command "print_facts"} prints all local facts of the current
   15.48    context, both named and unnamed ones; the ``@{text "!"}'' option indicates
   15.49    extra verbosity.
   15.50  
   15.51 -  \item @{command "print_term_bindings"} prints all term bindings that
   15.52 +  \<^descr> @{command "print_term_bindings"} prints all term bindings that
   15.53    are present in the context.
   15.54  
   15.55 -  \item @{command "find_theorems"}~@{text criteria} retrieves facts
   15.56 +  \<^descr> @{command "find_theorems"}~@{text criteria} retrieves facts
   15.57    from the theory or proof context matching all of given search
   15.58    criteria.  The criterion @{text "name: p"} selects all theorems
   15.59    whose fully qualified name matches pattern @{text p}, which may
   15.60 @@ -555,7 +555,7 @@
   15.61    default, duplicates are removed from the search result. Use
   15.62    @{text with_dups} to display duplicates.
   15.63  
   15.64 -  \item @{command "find_consts"}~@{text criteria} prints all constants
   15.65 +  \<^descr> @{command "find_consts"}~@{text criteria} prints all constants
   15.66    whose type meets all of the given criteria. The criterion @{text
   15.67    "strict: ty"} is met by any type that matches the type pattern
   15.68    @{text ty}.  Patterns may contain both the dummy type ``@{text _}''
   15.69 @@ -564,11 +564,11 @@
   15.70    the prefix ``@{text "-"}'' function as described for @{command
   15.71    "find_theorems"}.
   15.72  
   15.73 -  \item @{command "thm_deps"}~@{text "a\<^sub>1 \<dots> a\<^sub>n"}
   15.74 +  \<^descr> @{command "thm_deps"}~@{text "a\<^sub>1 \<dots> a\<^sub>n"}
   15.75    visualizes dependencies of facts, using Isabelle's graph browser
   15.76    tool (see also @{cite "isabelle-system"}).
   15.77  
   15.78 -  \item @{command "unused_thms"}~@{text "A\<^sub>1 \<dots> A\<^sub>m - B\<^sub>1 \<dots> B\<^sub>n"}
   15.79 +  \<^descr> @{command "unused_thms"}~@{text "A\<^sub>1 \<dots> A\<^sub>m - B\<^sub>1 \<dots> B\<^sub>n"}
   15.80    displays all theorems that are proved in theories @{text "B\<^sub>1 \<dots> B\<^sub>n"}
   15.81    or their parents but not in @{text "A\<^sub>1 \<dots> A\<^sub>m"} or their parents and
   15.82    that are never used.
    16.1 --- a/src/Doc/Isar_Ref/Proof.thy	Wed Oct 14 15:06:42 2015 +0200
    16.2 +++ b/src/Doc/Isar_Ref/Proof.thy	Wed Oct 14 15:10:32 2015 +0200
    16.3 @@ -13,16 +13,16 @@
    16.4  
    16.5    \begin{description}
    16.6  
    16.7 -  \item @{text "proof(prove)"} means that a new goal has just been
    16.8 +  \<^descr> @{text "proof(prove)"} means that a new goal has just been
    16.9    stated that is now to be \emph{proven}; the next command may refine
   16.10    it by some proof method, and enter a sub-proof to establish the
   16.11    actual result.
   16.12  
   16.13 -  \item @{text "proof(state)"} is like a nested theory mode: the
   16.14 +  \<^descr> @{text "proof(state)"} is like a nested theory mode: the
   16.15    context may be augmented by \emph{stating} additional assumptions,
   16.16    intermediate results etc.
   16.17  
   16.18 -  \item @{text "proof(chain)"} is intermediate between @{text
   16.19 +  \<^descr> @{text "proof(chain)"} is intermediate between @{text
   16.20    "proof(state)"} and @{text "proof(prove)"}: existing facts (i.e.\ the
   16.21    contents of the special @{fact_ref this} register) have been just picked
   16.22    up in order to be used when refining the goal claimed next.
   16.23 @@ -60,7 +60,7 @@
   16.24  
   16.25    \begin{description}
   16.26  
   16.27 -  \item @{command "notepad"}~@{keyword "begin"} opens a proof state without
   16.28 +  \<^descr> @{command "notepad"}~@{keyword "begin"} opens a proof state without
   16.29    any goal statement. This allows to experiment with Isar, without producing
   16.30    any persistent result. The notepad is closed by @{command "end"}.
   16.31  
   16.32 @@ -93,10 +93,10 @@
   16.33  
   16.34    \begin{description}
   16.35  
   16.36 -  \item @{command "next"} switches to a fresh block within a
   16.37 +  \<^descr> @{command "next"} switches to a fresh block within a
   16.38    sub-proof, resetting the local context to the initial one.
   16.39  
   16.40 -  \item @{command "{"} and @{command "}"} explicitly open and close
   16.41 +  \<^descr> @{command "{"} and @{command "}"} explicitly open and close
   16.42    blocks.  Any current facts pass through ``@{command "{"}''
   16.43    unchanged, while ``@{command "}"}'' causes any result to be
   16.44    \emph{exported} into the enclosing context.  Thus fixed variables
   16.45 @@ -192,10 +192,10 @@
   16.46  
   16.47    \begin{description}
   16.48  
   16.49 -  \item @{command "fix"}~@{text x} introduces a local variable @{text
   16.50 +  \<^descr> @{command "fix"}~@{text x} introduces a local variable @{text
   16.51    x} that is \emph{arbitrary, but fixed.}
   16.52  
   16.53 -  \item @{command "assume"}~@{text "a: \<phi>"} and @{command
   16.54 +  \<^descr> @{command "assume"}~@{text "a: \<phi>"} and @{command
   16.55    "presume"}~@{text "a: \<phi>"} introduce a local fact @{text "\<phi> \<turnstile> \<phi>"} by
   16.56    assumption.  Subsequent results applied to an enclosing goal (e.g.\
   16.57    by @{command_ref "show"}) are handled as follows: @{command
   16.58 @@ -206,7 +206,7 @@
   16.59    @{keyword_ref "and"}; the resulting list of current facts consists
   16.60    of all of these concatenated.
   16.61  
   16.62 -  \item @{command "def"}~@{text "x \<equiv> t"} introduces a local
   16.63 +  \<^descr> @{command "def"}~@{text "x \<equiv> t"} introduces a local
   16.64    (non-polymorphic) definition.  In results exported from the context,
   16.65    @{text x} is replaced by @{text t}.  Basically, ``@{command
   16.66    "def"}~@{text "x \<equiv> t"}'' abbreviates ``@{command "fix"}~@{text
   16.67 @@ -264,11 +264,11 @@
   16.68  
   16.69    \begin{description}
   16.70  
   16.71 -  \item @{command "let"}~@{text "p\<^sub>1 = t\<^sub>1 \<AND> \<dots> p\<^sub>n = t\<^sub>n"} binds any
   16.72 +  \<^descr> @{command "let"}~@{text "p\<^sub>1 = t\<^sub>1 \<AND> \<dots> p\<^sub>n = t\<^sub>n"} binds any
   16.73    text variables in patterns @{text "p\<^sub>1, \<dots>, p\<^sub>n"} by simultaneous
   16.74    higher-order matching against terms @{text "t\<^sub>1, \<dots>, t\<^sub>n"}.
   16.75  
   16.76 -  \item @{text "(\<IS> p\<^sub>1 \<dots> p\<^sub>n)"} resembles @{command "let"}, but
   16.77 +  \<^descr> @{text "(\<IS> p\<^sub>1 \<dots> p\<^sub>n)"} resembles @{command "let"}, but
   16.78    matches @{text "p\<^sub>1, \<dots>, p\<^sub>n"} against the preceding statement.  Also
   16.79    note that @{keyword "is"} is not a separate command, but part of
   16.80    others (such as @{command "assume"}, @{command "have"} etc.).
   16.81 @@ -320,12 +320,12 @@
   16.82  
   16.83    \begin{description}
   16.84  
   16.85 -  \item @{command "note"}~@{text "a = b\<^sub>1 \<dots> b\<^sub>n"} recalls existing facts
   16.86 +  \<^descr> @{command "note"}~@{text "a = b\<^sub>1 \<dots> b\<^sub>n"} recalls existing facts
   16.87    @{text "b\<^sub>1, \<dots>, b\<^sub>n"}, binding the result as @{text a}.  Note that
   16.88    attributes may be involved as well, both on the left and right hand
   16.89    sides.
   16.90  
   16.91 -  \item @{command "then"} indicates forward chaining by the current
   16.92 +  \<^descr> @{command "then"} indicates forward chaining by the current
   16.93    facts in order to establish the goal to be claimed next.  The
   16.94    initial proof method invoked to refine that will be offered the
   16.95    facts to do ``anything appropriate'' (see also
   16.96 @@ -335,19 +335,19 @@
   16.97    facts into the goal state before operation.  This provides a simple
   16.98    scheme to control relevance of facts in automated proof search.
   16.99  
  16.100 -  \item @{command "from"}~@{text b} abbreviates ``@{command
  16.101 +  \<^descr> @{command "from"}~@{text b} abbreviates ``@{command
  16.102    "note"}~@{text b}~@{command "then"}''; thus @{command "then"} is
  16.103    equivalent to ``@{command "from"}~@{text this}''.
  16.104  
  16.105 -  \item @{command "with"}~@{text "b\<^sub>1 \<dots> b\<^sub>n"} abbreviates ``@{command
  16.106 +  \<^descr> @{command "with"}~@{text "b\<^sub>1 \<dots> b\<^sub>n"} abbreviates ``@{command
  16.107    "from"}~@{text "b\<^sub>1 \<dots> b\<^sub>n \<AND> this"}''; thus the forward chaining
  16.108    is from earlier facts together with the current ones.
  16.109  
  16.110 -  \item @{command "using"}~@{text "b\<^sub>1 \<dots> b\<^sub>n"} augments the facts being
  16.111 +  \<^descr> @{command "using"}~@{text "b\<^sub>1 \<dots> b\<^sub>n"} augments the facts being
  16.112    currently indicated for use by a subsequent refinement step (such as
  16.113    @{command_ref "apply"} or @{command_ref "proof"}).
  16.114  
  16.115 -  \item @{command "unfolding"}~@{text "b\<^sub>1 \<dots> b\<^sub>n"} is structurally
  16.116 +  \<^descr> @{command "unfolding"}~@{text "b\<^sub>1 \<dots> b\<^sub>n"} is structurally
  16.117    similar to @{command "using"}, but unfolds definitional equations
  16.118    @{text "b\<^sub>1, \<dots> b\<^sub>n"} throughout the goal state and facts.
  16.119  
  16.120 @@ -445,7 +445,7 @@
  16.121  
  16.122    \begin{description}
  16.123  
  16.124 -  \item @{command "lemma"}~@{text "a: \<phi>"} enters proof mode with
  16.125 +  \<^descr> @{command "lemma"}~@{text "a: \<phi>"} enters proof mode with
  16.126    @{text \<phi>} as main goal, eventually resulting in some fact @{text "\<turnstile>
  16.127    \<phi>"} to be put back into the target context.  An additional @{syntax
  16.128    context} specification may build up an initial proof context for the
  16.129 @@ -453,11 +453,11 @@
  16.130    well, see also @{syntax "includes"} in \secref{sec:bundle} and
  16.131    @{syntax context_elem} in \secref{sec:locale}.
  16.132  
  16.133 -  \item @{command "theorem"}, @{command "corollary"}, and @{command
  16.134 +  \<^descr> @{command "theorem"}, @{command "corollary"}, and @{command
  16.135    "proposition"} are the same as @{command "lemma"}. The different command
  16.136    names merely serve as a formal comment in the theory source.
  16.137  
  16.138 -  \item @{command "schematic_goal"} is similar to @{command "theorem"},
  16.139 +  \<^descr> @{command "schematic_goal"} is similar to @{command "theorem"},
  16.140    but allows the statement to contain unbound schematic variables.
  16.141  
  16.142    Under normal circumstances, an Isar proof text needs to specify
  16.143 @@ -467,14 +467,14 @@
  16.144    proofs is lost, which also impacts performance, because proof
  16.145    checking is forced into sequential mode.
  16.146  
  16.147 -  \item @{command "have"}~@{text "a: \<phi>"} claims a local goal,
  16.148 +  \<^descr> @{command "have"}~@{text "a: \<phi>"} claims a local goal,
  16.149    eventually resulting in a fact within the current logical context.
  16.150    This operation is completely independent of any pending sub-goals of
  16.151    an enclosing goal statements, so @{command "have"} may be freely
  16.152    used for experimental exploration of potential results within a
  16.153    proof body.
  16.154  
  16.155 -  \item @{command "show"}~@{text "a: \<phi>"} is like @{command
  16.156 +  \<^descr> @{command "show"}~@{text "a: \<phi>"} is like @{command
  16.157    "have"}~@{text "a: \<phi>"} plus a second stage to refine some pending
  16.158    sub-goal for each one of the finished result, after having been
  16.159    exported into the corresponding context (at the head of the
  16.160 @@ -487,16 +487,16 @@
  16.161    following message:
  16.162    @{verbatim [display] \<open>Local statement fails to refine any pending goal\<close>}
  16.163  
  16.164 -  \item @{command "hence"} abbreviates ``@{command "then"}~@{command
  16.165 +  \<^descr> @{command "hence"} abbreviates ``@{command "then"}~@{command
  16.166    "have"}'', i.e.\ claims a local goal to be proven by forward
  16.167    chaining the current facts.  Note that @{command "hence"} is also
  16.168    equivalent to ``@{command "from"}~@{text this}~@{command "have"}''.
  16.169  
  16.170 -  \item @{command "thus"} abbreviates ``@{command "then"}~@{command
  16.171 +  \<^descr> @{command "thus"} abbreviates ``@{command "then"}~@{command
  16.172    "show"}''.  Note that @{command "thus"} is also equivalent to
  16.173    ``@{command "from"}~@{text this}~@{command "show"}''.
  16.174  
  16.175 -  \item @{command "print_statement"}~@{text a} prints facts from the
  16.176 +  \<^descr> @{command "print_statement"}~@{text a} prints facts from the
  16.177    current theory or proof context in long statement form, according to
  16.178    the syntax for @{command "lemma"} given above.
  16.179  
  16.180 @@ -576,7 +576,7 @@
  16.181  
  16.182    \begin{description}
  16.183  
  16.184 -  \item @{command "also"}~@{text "(a\<^sub>1 \<dots> a\<^sub>n)"} maintains the auxiliary
  16.185 +  \<^descr> @{command "also"}~@{text "(a\<^sub>1 \<dots> a\<^sub>n)"} maintains the auxiliary
  16.186    @{fact calculation} register as follows.  The first occurrence of
  16.187    @{command "also"} in some calculational thread initializes @{fact
  16.188    calculation} by @{fact this}. Any subsequent @{command "also"} on
  16.189 @@ -586,7 +586,7 @@
  16.190    current context, unless alternative rules are given as explicit
  16.191    arguments.
  16.192  
  16.193 -  \item @{command "finally"}~@{text "(a\<^sub>1 \<dots> a\<^sub>n)"} maintaining @{fact
  16.194 +  \<^descr> @{command "finally"}~@{text "(a\<^sub>1 \<dots> a\<^sub>n)"} maintaining @{fact
  16.195    calculation} in the same way as @{command "also"}, and concludes the
  16.196    current calculational thread.  The final result is exhibited as fact
  16.197    for forward chaining towards the next goal. Basically, @{command
  16.198 @@ -596,22 +596,22 @@
  16.199    "show"}~@{text ?thesis}~@{command "."}'' and ``@{command
  16.200    "finally"}~@{command "have"}~@{text \<phi>}~@{command "."}''.
  16.201  
  16.202 -  \item @{command "moreover"} and @{command "ultimately"} are
  16.203 +  \<^descr> @{command "moreover"} and @{command "ultimately"} are
  16.204    analogous to @{command "also"} and @{command "finally"}, but collect
  16.205    results only, without applying rules.
  16.206  
  16.207 -  \item @{command "print_trans_rules"} prints the list of transitivity
  16.208 +  \<^descr> @{command "print_trans_rules"} prints the list of transitivity
  16.209    rules (for calculational commands @{command "also"} and @{command
  16.210    "finally"}) and symmetry rules (for the @{attribute symmetric}
  16.211    operation and single step elimination patters) of the current
  16.212    context.
  16.213  
  16.214 -  \item @{attribute trans} declares theorems as transitivity rules.
  16.215 +  \<^descr> @{attribute trans} declares theorems as transitivity rules.
  16.216  
  16.217 -  \item @{attribute sym} declares symmetry rules, as well as
  16.218 +  \<^descr> @{attribute sym} declares symmetry rules, as well as
  16.219    @{attribute "Pure.elim"}@{text "?"} rules.
  16.220  
  16.221 -  \item @{attribute symmetric} resolves a theorem with some rule
  16.222 +  \<^descr> @{attribute symmetric} resolves a theorem with some rule
  16.223    declared as @{attribute sym} in the current context.  For example,
  16.224    ``@{command "assume"}~@{text "[symmetric]: x = y"}'' produces a
  16.225    swapped fact derived from that assumption.
  16.226 @@ -751,11 +751,11 @@
  16.227  
  16.228    \begin{description}
  16.229  
  16.230 -  \item @{command "proof"}~@{text "m\<^sub>1"} refines the goal by proof
  16.231 +  \<^descr> @{command "proof"}~@{text "m\<^sub>1"} refines the goal by proof
  16.232    method @{text "m\<^sub>1"}; facts for forward chaining are passed if so
  16.233    indicated by @{text "proof(chain)"} mode.
  16.234  
  16.235 -  \item @{command "qed"}~@{text "m\<^sub>2"} refines any remaining goals by
  16.236 +  \<^descr> @{command "qed"}~@{text "m\<^sub>2"} refines any remaining goals by
  16.237    proof method @{text "m\<^sub>2"} and concludes the sub-proof by assumption.
  16.238    If the goal had been @{text "show"} (or @{text "thus"}), some
  16.239    pending sub-goal is solved as well by the rule resulting from the
  16.240 @@ -768,7 +768,7 @@
  16.241    @{command "have"}, or weakening the local context by replacing
  16.242    occurrences of @{command "assume"} by @{command "presume"}.
  16.243  
  16.244 -  \item @{command "by"}~@{text "m\<^sub>1 m\<^sub>2"} is a \emph{terminal
  16.245 +  \<^descr> @{command "by"}~@{text "m\<^sub>1 m\<^sub>2"} is a \emph{terminal
  16.246    proof}\index{proof!terminal}; it abbreviates @{command
  16.247    "proof"}~@{text "m\<^sub>1"}~@{command "qed"}~@{text "m\<^sub>2"}, but with
  16.248    backtracking across both methods.  Debugging an unsuccessful
  16.249 @@ -777,15 +777,15 @@
  16.250    @{text "apply"}~@{text "m\<^sub>1"}) is already sufficient to see the
  16.251    problem.
  16.252  
  16.253 -  \item ``@{command ".."}'' is a \emph{standard
  16.254 +  \<^descr> ``@{command ".."}'' is a \emph{standard
  16.255    proof}\index{proof!standard}; it abbreviates @{command "by"}~@{text
  16.256    "standard"}.
  16.257  
  16.258 -  \item ``@{command "."}'' is a \emph{trivial
  16.259 +  \<^descr> ``@{command "."}'' is a \emph{trivial
  16.260    proof}\index{proof!trivial}; it abbreviates @{command "by"}~@{text
  16.261    "this"}.
  16.262  
  16.263 -  \item @{command "sorry"} is a \emph{fake proof}\index{proof!fake}
  16.264 +  \<^descr> @{command "sorry"} is a \emph{fake proof}\index{proof!fake}
  16.265    pretending to solve the pending claim without further ado.  This
  16.266    only works in interactive development, or if the @{attribute
  16.267    quick_and_dirty} is enabled.  Facts emerging from fake
  16.268 @@ -796,7 +796,7 @@
  16.269    The most important application of @{command "sorry"} is to support
  16.270    experimentation and top-down proof development.
  16.271  
  16.272 -  \item @{method standard} refers to the default refinement step of some
  16.273 +  \<^descr> @{method standard} refers to the default refinement step of some
  16.274    Isar language elements (notably @{command proof} and ``@{command ".."}'').
  16.275    It is \emph{dynamically scoped}, so the behaviour depends on the
  16.276    application environment.
  16.277 @@ -862,7 +862,7 @@
  16.278  
  16.279    \begin{description}
  16.280  
  16.281 -  \item @{command "print_rules"} prints rules declared via attributes
  16.282 +  \<^descr> @{command "print_rules"} prints rules declared via attributes
  16.283    @{attribute (Pure) intro}, @{attribute (Pure) elim}, @{attribute
  16.284    (Pure) dest} of Isabelle/Pure.
  16.285  
  16.286 @@ -870,7 +870,7 @@
  16.287    rule declarations of the classical reasoner
  16.288    (\secref{sec:classical}).
  16.289  
  16.290 -  \item ``@{method "-"}'' (minus) inserts the forward chaining facts as
  16.291 +  \<^descr> ``@{method "-"}'' (minus) inserts the forward chaining facts as
  16.292    premises into the goal, and nothing else.
  16.293  
  16.294    Note that command @{command_ref "proof"} without any method actually
  16.295 @@ -878,7 +878,7 @@
  16.296    method; thus a plain \emph{do-nothing} proof step would be ``@{command
  16.297    "proof"}~@{text "-"}'' rather than @{command "proof"} alone.
  16.298  
  16.299 -  \item @{method "goal_cases"}~@{text "a\<^sub>1 \<dots> a\<^sub>n"} turns the current subgoals
  16.300 +  \<^descr> @{method "goal_cases"}~@{text "a\<^sub>1 \<dots> a\<^sub>n"} turns the current subgoals
  16.301    into cases within the context (see also \secref{sec:cases-induct}). The
  16.302    specified case names are used if present; otherwise cases are numbered
  16.303    starting from 1.
  16.304 @@ -888,7 +888,7 @@
  16.305    premises, and @{command let} variable @{variable_ref ?case} refer to the
  16.306    conclusion.
  16.307  
  16.308 -  \item @{method "fact"}~@{text "a\<^sub>1 \<dots> a\<^sub>n"} composes some fact from
  16.309 +  \<^descr> @{method "fact"}~@{text "a\<^sub>1 \<dots> a\<^sub>n"} composes some fact from
  16.310    @{text "a\<^sub>1, \<dots>, a\<^sub>n"} (or implicitly from the current proof context)
  16.311    modulo unification of schematic type and term variables.  The rule
  16.312    structure is not taken into account, i.e.\ meta-level implication is
  16.313 @@ -899,7 +899,7 @@
  16.314    @{text "\<turnstile> \<phi>"} is an instance of some known @{text "\<turnstile> \<phi>"} in the
  16.315    proof context.
  16.316  
  16.317 -  \item @{method assumption} solves some goal by a single assumption
  16.318 +  \<^descr> @{method assumption} solves some goal by a single assumption
  16.319    step.  All given facts are guaranteed to participate in the
  16.320    refinement; this means there may be only 0 or 1 in the first place.
  16.321    Recall that @{command "qed"} (\secref{sec:proof-steps}) already
  16.322 @@ -907,11 +907,11 @@
  16.323    proofs usually need not quote the @{method assumption} method at
  16.324    all.
  16.325  
  16.326 -  \item @{method this} applies all of the current facts directly as
  16.327 +  \<^descr> @{method this} applies all of the current facts directly as
  16.328    rules.  Recall that ``@{command "."}'' (dot) abbreviates ``@{command
  16.329    "by"}~@{text this}''.
  16.330  
  16.331 -  \item @{method (Pure) rule}~@{text "a\<^sub>1 \<dots> a\<^sub>n"} applies some rule given as
  16.332 +  \<^descr> @{method (Pure) rule}~@{text "a\<^sub>1 \<dots> a\<^sub>n"} applies some rule given as
  16.333    argument in backward manner; facts are used to reduce the rule
  16.334    before applying it to the goal.  Thus @{method (Pure) rule} without facts
  16.335    is plain introduction, while with facts it becomes elimination.
  16.336 @@ -923,7 +923,7 @@
  16.337    behaviour of @{command "proof"} and ``@{command ".."}'' (double-dot) steps
  16.338    (see \secref{sec:proof-steps}).
  16.339  
  16.340 -  \item @{attribute (Pure) intro}, @{attribute (Pure) elim}, and
  16.341 +  \<^descr> @{attribute (Pure) intro}, @{attribute (Pure) elim}, and
  16.342    @{attribute (Pure) dest} declare introduction, elimination, and
  16.343    destruct rules, to be used with method @{method (Pure) rule}, and similar
  16.344    tools.  Note that the latter will ignore rules declared with
  16.345 @@ -934,10 +934,10 @@
  16.346    present versions of Isabelle/Pure, i.e.\ @{attribute (Pure)
  16.347    "Pure.intro"}.
  16.348  
  16.349 -  \item @{attribute (Pure) rule}~@{text del} undeclares introduction,
  16.350 +  \<^descr> @{attribute (Pure) rule}~@{text del} undeclares introduction,
  16.351    elimination, or destruct rules.
  16.352  
  16.353 -  \item @{attribute OF}~@{text "a\<^sub>1 \<dots> a\<^sub>n"} applies some theorem to all
  16.354 +  \<^descr> @{attribute OF}~@{text "a\<^sub>1 \<dots> a\<^sub>n"} applies some theorem to all
  16.355    of the given rules @{text "a\<^sub>1, \<dots>, a\<^sub>n"} in canonical right-to-left
  16.356    order, which means that premises stemming from the @{text "a\<^sub>i"}
  16.357    emerge in parallel in the result, without interfering with each
  16.358 @@ -949,7 +949,7 @@
  16.359    (underscore), which refers to the propositional identity rule in the
  16.360    Pure theory.
  16.361  
  16.362 -  \item @{attribute of}~@{text "t\<^sub>1 \<dots> t\<^sub>n"} performs positional
  16.363 +  \<^descr> @{attribute of}~@{text "t\<^sub>1 \<dots> t\<^sub>n"} performs positional
  16.364    instantiation of term variables.  The terms @{text "t\<^sub>1, \<dots>, t\<^sub>n"} are
  16.365    substituted for any schematic variables occurring in a theorem from
  16.366    left to right; ``@{text _}'' (underscore) indicates to skip a
  16.367 @@ -960,7 +960,7 @@
  16.368    be specified: the instantiated theorem is exported, and these
  16.369    variables become schematic (usually with some shifting of indices).
  16.370  
  16.371 -  \item @{attribute "where"}~@{text "x\<^sub>1 = t\<^sub>1 \<AND> \<dots> x\<^sub>n = t\<^sub>n"}
  16.372 +  \<^descr> @{attribute "where"}~@{text "x\<^sub>1 = t\<^sub>1 \<AND> \<dots> x\<^sub>n = t\<^sub>n"}
  16.373    performs named instantiation of schematic type and term variables
  16.374    occurring in a theorem.  Schematic variables have to be specified on
  16.375    the left-hand side (e.g.\ @{text "?x1.3"}).  The question mark may
  16.376 @@ -988,7 +988,7 @@
  16.377  
  16.378    \begin{description}
  16.379  
  16.380 -  \item @{command "method_setup"}~@{text "name = text description"}
  16.381 +  \<^descr> @{command "method_setup"}~@{text "name = text description"}
  16.382    defines a proof method in the current context.  The given @{text
  16.383    "text"} has to be an ML expression of type
  16.384    @{ML_type "(Proof.context -> Proof.method) context_parser"}, cf.\
  16.385 @@ -1096,7 +1096,7 @@
  16.386  
  16.387    \begin{description}
  16.388  
  16.389 -  \item @{command "case"}~@{text "a: (c x\<^sub>1 \<dots> x\<^sub>m)"} invokes a named local
  16.390 +  \<^descr> @{command "case"}~@{text "a: (c x\<^sub>1 \<dots> x\<^sub>m)"} invokes a named local
  16.391    context @{text "c: x\<^sub>1, \<dots>, x\<^sub>m, \<phi>\<^sub>1, \<dots>, \<phi>\<^sub>m"}, as provided by an
  16.392    appropriate proof method (such as @{method_ref cases} and @{method_ref
  16.393    induct}). The command ``@{command "case"}~@{text "a: (c x\<^sub>1 \<dots> x\<^sub>m)"}''
  16.394 @@ -1109,17 +1109,17 @@
  16.395    re-use @{text c}. So @{command "case"}~@{text "(c x\<^sub>1 \<dots> x\<^sub>m)"} is the same
  16.396    as @{command "case"}~@{text "c: (c x\<^sub>1 \<dots> x\<^sub>m)"}.
  16.397  
  16.398 -  \item @{command "print_cases"} prints all local contexts of the
  16.399 +  \<^descr> @{command "print_cases"} prints all local contexts of the
  16.400    current state, using Isar proof language notation.
  16.401  
  16.402 -  \item @{attribute case_names}~@{text "c\<^sub>1 \<dots> c\<^sub>k"} declares names for
  16.403 +  \<^descr> @{attribute case_names}~@{text "c\<^sub>1 \<dots> c\<^sub>k"} declares names for
  16.404    the local contexts of premises of a theorem; @{text "c\<^sub>1, \<dots>, c\<^sub>k"}
  16.405    refers to the \emph{prefix} of the list of premises. Each of the
  16.406    cases @{text "c\<^sub>i"} can be of the form @{text "c[h\<^sub>1 \<dots> h\<^sub>n]"} where
  16.407    the @{text "h\<^sub>1 \<dots> h\<^sub>n"} are the names of the hypotheses in case @{text "c\<^sub>i"}
  16.408    from left to right.
  16.409  
  16.410 -  \item @{attribute case_conclusion}~@{text "c d\<^sub>1 \<dots> d\<^sub>k"} declares
  16.411 +  \<^descr> @{attribute case_conclusion}~@{text "c d\<^sub>1 \<dots> d\<^sub>k"} declares
  16.412    names for the conclusions of a named premise @{text c}; here @{text
  16.413    "d\<^sub>1, \<dots>, d\<^sub>k"} refers to the prefix of arguments of a logical formula
  16.414    built by nesting a binary connective (e.g.\ @{text "\<or>"}).
  16.415 @@ -1129,7 +1129,7 @@
  16.416    whole.  The need to name subformulas only arises with cases that
  16.417    split into several sub-cases, as in common co-induction rules.
  16.418  
  16.419 -  \item @{attribute params}~@{text "p\<^sub>1 \<dots> p\<^sub>m \<AND> \<dots> q\<^sub>1 \<dots> q\<^sub>n"} renames
  16.420 +  \<^descr> @{attribute params}~@{text "p\<^sub>1 \<dots> p\<^sub>m \<AND> \<dots> q\<^sub>1 \<dots> q\<^sub>n"} renames
  16.421    the innermost parameters of premises @{text "1, \<dots>, n"} of some
  16.422    theorem.  An empty list of names may be given to skip positions,
  16.423    leaving the present parameters unchanged.
  16.424 @@ -1137,7 +1137,7 @@
  16.425    Note that the default usage of case rules does \emph{not} directly
  16.426    expose parameters to the proof context.
  16.427  
  16.428 -  \item @{attribute consumes}~@{text n} declares the number of ``major
  16.429 +  \<^descr> @{attribute consumes}~@{text n} declares the number of ``major
  16.430    premises'' of a rule, i.e.\ the number of facts to be consumed when
  16.431    it is applied by an appropriate proof method.  The default value of
  16.432    @{attribute consumes} is @{text "n = 1"}, which is appropriate for
  16.433 @@ -1216,7 +1216,7 @@
  16.434  
  16.435    \begin{description}
  16.436  
  16.437 -  \item @{method cases}~@{text "insts R"} applies method @{method
  16.438 +  \<^descr> @{method cases}~@{text "insts R"} applies method @{method
  16.439    rule} with an appropriate case distinction theorem, instantiated to
  16.440    the subjects @{text insts}.  Symbolic case names are bound according
  16.441    to the rule's local contexts.
  16.442 @@ -1243,7 +1243,7 @@
  16.443    "(no_simp)"} option can be used to disable pre-simplification of
  16.444    cases (see the description of @{method induct} below for details).
  16.445  
  16.446 -  \item @{method induct}~@{text "insts R"} and
  16.447 +  \<^descr> @{method induct}~@{text "insts R"} and
  16.448    @{method induction}~@{text "insts R"} are analogous to the
  16.449    @{method cases} method, but refer to induction rules, which are
  16.450    determined as follows:
  16.451 @@ -1300,7 +1300,7 @@
  16.452    pending variables in the rule.  Such schematic induction rules
  16.453    rarely occur in practice, though.
  16.454  
  16.455 -  \item @{method coinduct}~@{text "inst R"} is analogous to the
  16.456 +  \<^descr> @{method coinduct}~@{text "inst R"} is analogous to the
  16.457    @{method induct} method, but refers to coinduction rules, which are
  16.458    determined as follows:
  16.459  
  16.460 @@ -1406,10 +1406,10 @@
  16.461  
  16.462    \begin{description}
  16.463  
  16.464 -  \item @{command "print_induct_rules"} prints cases and induct rules
  16.465 +  \<^descr> @{command "print_induct_rules"} prints cases and induct rules
  16.466    for predicates (or sets) and types of the current context.
  16.467  
  16.468 -  \item @{attribute cases}, @{attribute induct}, and @{attribute
  16.469 +  \<^descr> @{attribute cases}, @{attribute induct}, and @{attribute
  16.470    coinduct} (as attributes) declare rules for reasoning about
  16.471    (co)inductive predicates (or sets) and types, using the
  16.472    corresponding methods of the same name.  Certain definitional
  16.473 @@ -1472,7 +1472,7 @@
  16.474  
  16.475    \begin{description}
  16.476  
  16.477 -  \item @{command consider}~@{text "(a) \<^vec>x \<WHERE> \<^vec>A \<^vec>x
  16.478 +  \<^descr> @{command consider}~@{text "(a) \<^vec>x \<WHERE> \<^vec>A \<^vec>x
  16.479    | (b) \<^vec>y \<WHERE> \<^vec>B \<^vec>y | \<dots> "} states a rule for case
  16.480    splitting into separate subgoals, such that each case involves new
  16.481    parameters and premises. After the proof is finished, the resulting rule
  16.482 @@ -1502,7 +1502,7 @@
  16.483    statements, as well as @{command print_statement} to print existing rules
  16.484    in a similar format.
  16.485  
  16.486 -  \item @{command obtain}~@{text "\<^vec>x \<WHERE> \<^vec>A \<^vec>x"}
  16.487 +  \<^descr> @{command obtain}~@{text "\<^vec>x \<WHERE> \<^vec>A \<^vec>x"}
  16.488    states a generalized elimination rule with exactly one case. After the
  16.489    proof is finished, it is activated for the subsequent proof text: the
  16.490    context is augmented via @{command fix}~@{text "\<^vec>x"} @{command
  16.491 @@ -1529,7 +1529,7 @@
  16.492      \quad @{command "fix"}~@{text "\<^vec>x"}~@{command "assume"}@{text "\<^sup>* a: \<^vec>A \<^vec>x"} \\
  16.493    \end{matharray}
  16.494  
  16.495 -  \item @{command guess} is similar to @{command obtain}, but it derives the
  16.496 +  \<^descr> @{command guess} is similar to @{command obtain}, but it derives the
  16.497    obtained context elements from the course of tactical reasoning in the
  16.498    proof. Thus it can considerably obscure the proof: it is classified as
  16.499    \emph{improper}.
    17.1 --- a/src/Doc/Isar_Ref/Proof_Script.thy	Wed Oct 14 15:06:42 2015 +0200
    17.2 +++ b/src/Doc/Isar_Ref/Proof_Script.thy	Wed Oct 14 15:10:32 2015 +0200
    17.3 @@ -43,11 +43,11 @@
    17.4  
    17.5    \begin{description}
    17.6  
    17.7 -  \item @{command "supply"} supports fact definitions during goal
    17.8 +  \<^descr> @{command "supply"} supports fact definitions during goal
    17.9    refinement: it is similar to @{command "note"}, but it operates in
   17.10    backwards mode and does not have any impact on chained facts.
   17.11  
   17.12 -  \item @{command "apply"}~@{text m} applies proof method @{text m} in
   17.13 +  \<^descr> @{command "apply"}~@{text m} applies proof method @{text m} in
   17.14    initial position, but unlike @{command "proof"} it retains ``@{text
   17.15    "proof(prove)"}'' mode.  Thus consecutive method applications may be
   17.16    given just as in tactic scripts.
   17.17 @@ -57,7 +57,7 @@
   17.18    further @{command "apply"} command would always work in a purely
   17.19    backward manner.
   17.20  
   17.21 -  \item @{command "apply_end"}~@{text "m"} applies proof method @{text
   17.22 +  \<^descr> @{command "apply_end"}~@{text "m"} applies proof method @{text
   17.23    m} as if in terminal position.  Basically, this simulates a
   17.24    multi-step tactic script for @{command "qed"}, but may be given
   17.25    anywhere within the proof body.
   17.26 @@ -67,18 +67,18 @@
   17.27    "qed"}).  Thus the proof method may not refer to any assumptions
   17.28    introduced in the current body, for example.
   17.29  
   17.30 -  \item @{command "done"} completes a proof script, provided that the
   17.31 +  \<^descr> @{command "done"} completes a proof script, provided that the
   17.32    current goal state is solved completely.  Note that actual
   17.33    structured proof commands (e.g.\ ``@{command "."}'' or @{command
   17.34    "sorry"}) may be used to conclude proof scripts as well.
   17.35  
   17.36 -  \item @{command "defer"}~@{text n} and @{command "prefer"}~@{text n}
   17.37 +  \<^descr> @{command "defer"}~@{text n} and @{command "prefer"}~@{text n}
   17.38    shuffle the list of pending goals: @{command "defer"} puts off
   17.39    sub-goal @{text n} to the end of the list (@{text "n = 1"} by
   17.40    default), while @{command "prefer"} brings sub-goal @{text n} to the
   17.41    front.
   17.42  
   17.43 -  \item @{command "back"} does back-tracking over the result sequence
   17.44 +  \<^descr> @{command "back"} does back-tracking over the result sequence
   17.45    of the latest proof command.  Any proof command may return multiple
   17.46    results, and this command explores the possibilities step-by-step.
   17.47    It is mainly useful for experimentation and interactive exploration,
   17.48 @@ -105,7 +105,7 @@
   17.49  
   17.50    \begin{description}
   17.51  
   17.52 -  \item @{command "subgoal"} allows to impose some structure on backward
   17.53 +  \<^descr> @{command "subgoal"} allows to impose some structure on backward
   17.54    refinements, to avoid proof scripts degenerating into long of @{command
   17.55    apply} sequences.
   17.56  
   17.57 @@ -247,7 +247,7 @@
   17.58  
   17.59  \begin{description}
   17.60  
   17.61 -  \item @{method rule_tac} etc. do resolution of rules with explicit
   17.62 +  \<^descr> @{method rule_tac} etc. do resolution of rules with explicit
   17.63    instantiation.  This works the same way as the ML tactics @{ML
   17.64    Rule_Insts.res_inst_tac} etc.\ (see @{cite "isabelle-implementation"}).
   17.65  
   17.66 @@ -255,40 +255,40 @@
   17.67    @{method rule_tac} is the same as @{ML resolve_tac} in ML (see
   17.68    @{cite "isabelle-implementation"}).
   17.69  
   17.70 -  \item @{method cut_tac} inserts facts into the proof state as
   17.71 +  \<^descr> @{method cut_tac} inserts facts into the proof state as
   17.72    assumption of a subgoal; instantiations may be given as well.  Note
   17.73    that the scope of schematic variables is spread over the main goal
   17.74    statement and rule premises are turned into new subgoals.  This is
   17.75    in contrast to the regular method @{method insert} which inserts
   17.76    closed rule statements.
   17.77  
   17.78 -  \item @{method thin_tac}~@{text \<phi>} deletes the specified premise
   17.79 +  \<^descr> @{method thin_tac}~@{text \<phi>} deletes the specified premise
   17.80    from a subgoal.  Note that @{text \<phi>} may contain schematic
   17.81    variables, to abbreviate the intended proposition; the first
   17.82    matching subgoal premise will be deleted.  Removing useless premises
   17.83    from a subgoal increases its readability and can make search tactics
   17.84    run faster.
   17.85  
   17.86 -  \item @{method subgoal_tac}~@{text "\<phi>\<^sub>1 \<dots> \<phi>\<^sub>n"} adds the propositions
   17.87 +  \<^descr> @{method subgoal_tac}~@{text "\<phi>\<^sub>1 \<dots> \<phi>\<^sub>n"} adds the propositions
   17.88    @{text "\<phi>\<^sub>1 \<dots> \<phi>\<^sub>n"} as local premises to a subgoal, and poses the same
   17.89    as new subgoals (in the original context).
   17.90  
   17.91 -  \item @{method rename_tac}~@{text "x\<^sub>1 \<dots> x\<^sub>n"} renames parameters of a
   17.92 +  \<^descr> @{method rename_tac}~@{text "x\<^sub>1 \<dots> x\<^sub>n"} renames parameters of a
   17.93    goal according to the list @{text "x\<^sub>1, \<dots>, x\<^sub>n"}, which refers to the
   17.94    \emph{suffix} of variables.
   17.95  
   17.96 -  \item @{method rotate_tac}~@{text n} rotates the premises of a
   17.97 +  \<^descr> @{method rotate_tac}~@{text n} rotates the premises of a
   17.98    subgoal by @{text n} positions: from right to left if @{text n} is
   17.99    positive, and from left to right if @{text n} is negative; the
  17.100    default value is 1.
  17.101  
  17.102 -  \item @{method tactic}~@{text "text"} produces a proof method from
  17.103 +  \<^descr> @{method tactic}~@{text "text"} produces a proof method from
  17.104    any ML text of type @{ML_type tactic}.  Apart from the usual ML
  17.105    environment and the current proof context, the ML code may refer to
  17.106    the locally bound values @{ML_text facts}, which indicates any
  17.107    current facts used for forward-chaining.
  17.108  
  17.109 -  \item @{method raw_tactic} is similar to @{method tactic}, but
  17.110 +  \<^descr> @{method raw_tactic} is similar to @{method tactic}, but
  17.111    presents the goal state in its raw internal form, where simultaneous
  17.112    subgoals appear as conjunction of the logical framework instead of
  17.113    the usual split into several subgoals.  While feature this is useful
    18.1 --- a/src/Doc/Isar_Ref/Spec.thy	Wed Oct 14 15:06:42 2015 +0200
    18.2 +++ b/src/Doc/Isar_Ref/Spec.thy	Wed Oct 14 15:10:32 2015 +0200
    18.3 @@ -74,7 +74,7 @@
    18.4  
    18.5    \begin{description}
    18.6  
    18.7 -  \item @{command "theory"}~@{text "A \<IMPORTS> B\<^sub>1 \<dots> B\<^sub>n \<BEGIN>"}
    18.8 +  \<^descr> @{command "theory"}~@{text "A \<IMPORTS> B\<^sub>1 \<dots> B\<^sub>n \<BEGIN>"}
    18.9    starts a new theory @{text A} based on the merge of existing
   18.10    theories @{text "B\<^sub>1 \<dots> B\<^sub>n"}.  Due to the possibility to import more
   18.11    than one ancestor, the resulting theory structure of an Isabelle
   18.12 @@ -104,13 +104,13 @@
   18.13    It is possible to specify an alternative completion via @{verbatim
   18.14    "=="}~@{text "text"}, while the default is the corresponding keyword name.
   18.15    
   18.16 -  \item @{command (global) "end"} concludes the current theory
   18.17 +  \<^descr> @{command (global) "end"} concludes the current theory
   18.18    definition.  Note that some other commands, e.g.\ local theory
   18.19    targets @{command locale} or @{command class} may involve a
   18.20    @{keyword "begin"} that needs to be matched by @{command (local)
   18.21    "end"}, according to the usual rules for nested blocks.
   18.22  
   18.23 -  \item @{command thy_deps} visualizes the theory hierarchy as a directed
   18.24 +  \<^descr> @{command thy_deps} visualizes the theory hierarchy as a directed
   18.25    acyclic graph. By default, all imported theories are shown, taking the
   18.26    base session as a starting point. Alternatively, it is possibly to
   18.27    restrict the full theory graph by giving bounds, analogously to
   18.28 @@ -155,13 +155,13 @@
   18.29  
   18.30    \begin{description}
   18.31    
   18.32 -  \item @{command "context"}~@{text "c \<BEGIN>"} opens a named
   18.33 +  \<^descr> @{command "context"}~@{text "c \<BEGIN>"} opens a named
   18.34    context, by recommencing an existing locale or class @{text c}.
   18.35    Note that locale and class definitions allow to include the
   18.36    @{keyword "begin"} keyword as well, in order to continue the local
   18.37    theory immediately after the initial specification.
   18.38  
   18.39 -  \item @{command "context"}~@{text "bundles elements \<BEGIN>"} opens
   18.40 +  \<^descr> @{command "context"}~@{text "bundles elements \<BEGIN>"} opens
   18.41    an unnamed context, by extending the enclosing global or local
   18.42    theory target by the given declaration bundles (\secref{sec:bundle})
   18.43    and context elements (@{text "\<FIXES>"}, @{text "\<ASSUMES>"}
   18.44 @@ -169,12 +169,12 @@
   18.45    in the extended context will be exported into the enclosing target
   18.46    by lifting over extra parameters and premises.
   18.47    
   18.48 -  \item @{command (local) "end"} concludes the current local theory,
   18.49 +  \<^descr> @{command (local) "end"} concludes the current local theory,
   18.50    according to the nesting of contexts.  Note that a global @{command
   18.51    (global) "end"} has a different meaning: it concludes the theory
   18.52    itself (\secref{sec:begin-thy}).
   18.53    
   18.54 -  \item @{keyword "private"} or @{keyword "qualified"} may be given as
   18.55 +  \<^descr> @{keyword "private"} or @{keyword "qualified"} may be given as
   18.56    modifiers before any local theory command. This restricts name space
   18.57    accesses to the local scope, as determined by the enclosing @{command
   18.58    "context"}~@{keyword "begin"}~\dots~@{command "end"} block. Outside its
   18.59 @@ -185,7 +185,7 @@
   18.60    a local scope by itself: an extra unnamed context is required to use
   18.61    @{keyword "private"} or @{keyword "qualified"} here.
   18.62  
   18.63 -  \item @{text "("}@{keyword_def "in"}~@{text "c)"} given after any local
   18.64 +  \<^descr> @{text "("}@{keyword_def "in"}~@{text "c)"} given after any local
   18.65    theory command specifies an immediate target, e.g.\ ``@{command
   18.66    "definition"}~@{text "(\<IN> c)"}'' or ``@{command "theorem"}~@{text
   18.67    "(\<IN> c)"}''. This works both in a local or global theory context; the
   18.68 @@ -258,28 +258,28 @@
   18.69  
   18.70    \begin{description}
   18.71  
   18.72 -  \item @{command bundle}~@{text "b = decls"} defines a bundle of
   18.73 +  \<^descr> @{command bundle}~@{text "b = decls"} defines a bundle of
   18.74    declarations in the current context.  The RHS is similar to the one
   18.75    of the @{command declare} command.  Bundles defined in local theory
   18.76    targets are subject to transformations via morphisms, when moved
   18.77    into different application contexts; this works analogously to any
   18.78    other local theory specification.
   18.79  
   18.80 -  \item @{command print_bundles} prints the named bundles that are available
   18.81 +  \<^descr> @{command print_bundles} prints the named bundles that are available
   18.82    in the current context; the ``@{text "!"}'' option indicates extra
   18.83    verbosity.
   18.84  
   18.85 -  \item @{command include}~@{text "b\<^sub>1 \<dots> b\<^sub>n"} includes the declarations
   18.86 +  \<^descr> @{command include}~@{text "b\<^sub>1 \<dots> b\<^sub>n"} includes the declarations
   18.87    from the given bundles into the current proof body context.  This is
   18.88    analogous to @{command "note"} (\secref{sec:proof-facts}) with the
   18.89    expanded bundles.
   18.90  
   18.91 -  \item @{command including} is similar to @{command include}, but
   18.92 +  \<^descr> @{command including} is similar to @{command include}, but
   18.93    works in proof refinement (backward mode).  This is analogous to
   18.94    @{command "using"} (\secref{sec:proof-facts}) with the expanded
   18.95    bundles.
   18.96  
   18.97 -  \item @{keyword "includes"}~@{text "b\<^sub>1 \<dots> b\<^sub>n"} is similar to
   18.98 +  \<^descr> @{keyword "includes"}~@{text "b\<^sub>1 \<dots> b\<^sub>n"} is similar to
   18.99    @{command include}, but works in situations where a specification
  18.100    context is constructed, notably for @{command context} and long
  18.101    statements of @{command theorem} etc.
  18.102 @@ -326,7 +326,7 @@
  18.103  
  18.104    \begin{description}
  18.105    
  18.106 -  \item @{command "definition"}~@{text "c \<WHERE> eq"} produces an
  18.107 +  \<^descr> @{command "definition"}~@{text "c \<WHERE> eq"} produces an
  18.108    internal definition @{text "c \<equiv> t"} according to the specification
  18.109    given as @{text eq}, which is then turned into a proven fact.  The
  18.110    given proposition may deviate from internal meta-level equality
  18.111 @@ -340,10 +340,10 @@
  18.112    @{text "f \<equiv> \<lambda>x y. t"} and @{text "y \<noteq> 0 \<Longrightarrow> g x y = u"} instead of an
  18.113    unrestricted @{text "g \<equiv> \<lambda>x y. u"}.
  18.114  
  18.115 -  \item @{command "print_defn_rules"} prints the definitional rewrite rules
  18.116 +  \<^descr> @{command "print_defn_rules"} prints the definitional rewrite rules
  18.117    declared via @{attribute defn} in the current context.
  18.118  
  18.119 -  \item @{command "abbreviation"}~@{text "c \<WHERE> eq"} introduces a
  18.120 +  \<^descr> @{command "abbreviation"}~@{text "c \<WHERE> eq"} introduces a
  18.121    syntactic constant which is associated with a certain term according
  18.122    to the meta-level equality @{text eq}.
  18.123    
  18.124 @@ -360,7 +360,7 @@
  18.125    declared for abbreviations, cf.\ @{command "syntax"} in
  18.126    \secref{sec:syn-trans}.
  18.127    
  18.128 -  \item @{command "print_abbrevs"} prints all constant abbreviations of the
  18.129 +  \<^descr> @{command "print_abbrevs"} prints all constant abbreviations of the
  18.130    current context; the ``@{text "!"}'' option indicates extra verbosity.
  18.131    
  18.132    \end{description}
  18.133 @@ -382,7 +382,7 @@
  18.134  
  18.135    \begin{description}
  18.136  
  18.137 -  \item @{command "axiomatization"}~@{text "c\<^sub>1 \<dots> c\<^sub>m \<WHERE> \<phi>\<^sub>1 \<dots> \<phi>\<^sub>n"}
  18.138 +  \<^descr> @{command "axiomatization"}~@{text "c\<^sub>1 \<dots> c\<^sub>m \<WHERE> \<phi>\<^sub>1 \<dots> \<phi>\<^sub>n"}
  18.139    introduces several constants simultaneously and states axiomatic
  18.140    properties for these. The constants are marked as being specified once and
  18.141    for all, which prevents additional specifications for the same constants
  18.142 @@ -432,7 +432,7 @@
  18.143  
  18.144    \begin{description}
  18.145  
  18.146 -  \item @{command "declaration"}~@{text d} adds the declaration
  18.147 +  \<^descr> @{command "declaration"}~@{text d} adds the declaration
  18.148    function @{text d} of ML type @{ML_type declaration}, to the current
  18.149    local theory under construction.  In later application contexts, the
  18.150    function is transformed according to the morphisms being involved in
  18.151 @@ -442,11 +442,11 @@
  18.152    declaration is applied to all possible contexts involved, including
  18.153    the global background theory.
  18.154  
  18.155 -  \item @{command "syntax_declaration"} is similar to @{command
  18.156 +  \<^descr> @{command "syntax_declaration"} is similar to @{command
  18.157    "declaration"}, but is meant to affect only ``syntactic'' tools by
  18.158    convention (such as notation and type-checking information).
  18.159  
  18.160 -  \item @{command "declare"}~@{text thms} declares theorems to the
  18.161 +  \<^descr> @{command "declare"}~@{text thms} declares theorems to the
  18.162    current local theory context.  No theorem binding is involved here,
  18.163    unlike @{command "lemmas"} (cf.\ \secref{sec:theorems}), so
  18.164    @{command "declare"} only has the effect of applying attributes as
  18.165 @@ -565,7 +565,7 @@
  18.166  
  18.167    \begin{description}
  18.168    
  18.169 -  \item @{command "locale"}~@{text "loc = import + body"} defines a
  18.170 +  \<^descr> @{command "locale"}~@{text "loc = import + body"} defines a
  18.171    new locale @{text loc} as a context consisting of a certain view of
  18.172    existing locales (@{text import}) plus some additional elements
  18.173    (@{text body}).  Both @{text import} and @{text body} are optional;
  18.174 @@ -590,29 +590,29 @@
  18.175  
  18.176    \begin{description}
  18.177  
  18.178 -  \item @{element "fixes"}~@{text "x :: \<tau> (mx)"} declares a local
  18.179 +  \<^descr> @{element "fixes"}~@{text "x :: \<tau> (mx)"} declares a local
  18.180    parameter of type @{text \<tau>} and mixfix annotation @{text mx} (both
  18.181    are optional).  The special syntax declaration ``@{text
  18.182    "("}@{keyword_ref "structure"}@{text ")"}'' means that @{text x} may
  18.183    be referenced implicitly in this context.
  18.184  
  18.185 -  \item @{element "constrains"}~@{text "x :: \<tau>"} introduces a type
  18.186 +  \<^descr> @{element "constrains"}~@{text "x :: \<tau>"} introduces a type
  18.187    constraint @{text \<tau>} on the local parameter @{text x}.  This
  18.188    element is deprecated.  The type constraint should be introduced in
  18.189    the @{keyword "for"} clause or the relevant @{element "fixes"} element.
  18.190  
  18.191 -  \item @{element "assumes"}~@{text "a: \<phi>\<^sub>1 \<dots> \<phi>\<^sub>n"}
  18.192 +  \<^descr> @{element "assumes"}~@{text "a: \<phi>\<^sub>1 \<dots> \<phi>\<^sub>n"}
  18.193    introduces local premises, similar to @{command "assume"} within a
  18.194    proof (cf.\ \secref{sec:proof-context}).
  18.195  
  18.196 -  \item @{element "defines"}~@{text "a: x \<equiv> t"} defines a previously
  18.197 +  \<^descr> @{element "defines"}~@{text "a: x \<equiv> t"} defines a previously
  18.198    declared parameter.  This is similar to @{command "def"} within a
  18.199    proof (cf.\ \secref{sec:proof-context}), but @{element "defines"}
  18.200    takes an equational proposition instead of variable-term pair.  The
  18.201    left-hand side of the equation may have additional arguments, e.g.\
  18.202    ``@{element "defines"}~@{text "f x\<^sub>1 \<dots> x\<^sub>n \<equiv> t"}''.
  18.203  
  18.204 -  \item @{element "notes"}~@{text "a = b\<^sub>1 \<dots> b\<^sub>n"}
  18.205 +  \<^descr> @{element "notes"}~@{text "a = b\<^sub>1 \<dots> b\<^sub>n"}
  18.206    reconsiders facts within a local context.  Most notably, this may
  18.207    include arbitrary declarations in any attribute specifications
  18.208    included here, e.g.\ a local @{attribute simp} rule.
  18.209 @@ -649,25 +649,25 @@
  18.210    \secref{sec:object-logic}).  Separate introduction rules @{text
  18.211    loc_axioms.intro} and @{text loc.intro} are provided as well.
  18.212  
  18.213 -  \item @{command experiment}~@{text exprs}~@{keyword "begin"} opens an
  18.214 +  \<^descr> @{command experiment}~@{text exprs}~@{keyword "begin"} opens an
  18.215    anonymous locale context with private naming policy. Specifications in its
  18.216    body are inaccessible from outside. This is useful to perform experiments,
  18.217    without polluting the name space.
  18.218  
  18.219 -  \item @{command "print_locale"}~@{text "locale"} prints the
  18.220 +  \<^descr> @{command "print_locale"}~@{text "locale"} prints the
  18.221    contents of the named locale.  The command omits @{element "notes"}
  18.222    elements by default.  Use @{command "print_locale"}@{text "!"} to
  18.223    have them included.
  18.224  
  18.225 -  \item @{command "print_locales"} prints the names of all locales of the
  18.226 +  \<^descr> @{command "print_locales"} prints the names of all locales of the
  18.227    current theory; the ``@{text "!"}'' option indicates extra verbosity.
  18.228  
  18.229 -  \item @{command "locale_deps"} visualizes all locales and their
  18.230 +  \<^descr> @{command "locale_deps"} visualizes all locales and their
  18.231    relations as a Hasse diagram. This includes locales defined as type
  18.232    classes (\secref{sec:class}).  See also @{command
  18.233    "print_dependencies"} below.
  18.234  
  18.235 -  \item @{method intro_locales} and @{method unfold_locales}
  18.236 +  \<^descr> @{method intro_locales} and @{method unfold_locales}
  18.237    repeatedly expand all introduction rules of locale predicates of the
  18.238    theory.  While @{method intro_locales} only applies the @{text
  18.239    loc.intro} introduction rules and therefore does not descend to
  18.240 @@ -718,7 +718,7 @@
  18.241  
  18.242    \begin{description}
  18.243  
  18.244 -  \item @{command "interpretation"}~@{text "expr \<WHERE> eqns"}
  18.245 +  \<^descr> @{command "interpretation"}~@{text "expr \<WHERE> eqns"}
  18.246    interprets @{text expr} in a global or local theory.  The command
  18.247    generates proof obligations for the instantiated specifications.
  18.248    Once these are discharged by the user, instantiated declarations (in
  18.249 @@ -759,13 +759,13 @@
  18.250    concepts introduced through definitions.  The equations must be
  18.251    proved.
  18.252  
  18.253 -  \item @{command "interpret"}~@{text "expr \<WHERE> eqns"} interprets
  18.254 +  \<^descr> @{command "interpret"}~@{text "expr \<WHERE> eqns"} interprets
  18.255    @{text expr} in the proof context and is otherwise similar to
  18.256    interpretation in local theories.  Note that for @{command
  18.257    "interpret"} the @{text eqns} should be
  18.258    explicitly universally quantified.
  18.259  
  18.260 -  \item @{command "sublocale"}~@{text "name \<subseteq> expr \<WHERE>
  18.261 +  \<^descr> @{command "sublocale"}~@{text "name \<subseteq> expr \<WHERE>
  18.262    eqns"}
  18.263    interprets @{text expr} in the locale @{text name}.  A proof that
  18.264    the specification of @{text name} implies the specification of
  18.265 @@ -798,7 +798,7 @@
  18.266    be used, but the locale argument must be omitted.  The command then
  18.267    refers to the locale (or class) target of the context block.
  18.268  
  18.269 -  \item @{command "print_dependencies"}~@{text "expr"} is useful for
  18.270 +  \<^descr> @{command "print_dependencies"}~@{text "expr"} is useful for
  18.271    understanding the effect of an interpretation of @{text "expr"} in
  18.272    the current context.  It lists all locale instances for which
  18.273    interpretations would be added to the current context.  Variant
  18.274 @@ -808,7 +808,7 @@
  18.275    latter is useful for understanding the dependencies of a locale
  18.276    expression.
  18.277  
  18.278 -  \item @{command "print_interps"}~@{text "locale"} lists all
  18.279 +  \<^descr> @{command "print_interps"}~@{text "locale"} lists all
  18.280    interpretations of @{text "locale"} in the current theory or proof
  18.281    context, including those due to a combination of an @{command
  18.282    "interpretation"} or @{command "interpret"} and one or several
  18.283 @@ -874,7 +874,7 @@
  18.284  
  18.285    \begin{description}
  18.286  
  18.287 -  \item @{command "permanent_interpretation"}~@{text "expr \<DEFINING> defs \<WHERE> eqns"}
  18.288 +  \<^descr> @{command "permanent_interpretation"}~@{text "expr \<DEFINING> defs \<WHERE> eqns"}
  18.289    interprets @{text expr} in the current local theory.  The command
  18.290    generates proof obligations for the instantiated specifications.
  18.291    Instantiated declarations (in particular, facts) are added to the
  18.292 @@ -972,7 +972,7 @@
  18.293  
  18.294    \begin{description}
  18.295  
  18.296 -  \item @{command "class"}~@{text "c = superclasses + body"} defines
  18.297 +  \<^descr> @{command "class"}~@{text "c = superclasses + body"} defines
  18.298    a new class @{text c}, inheriting from @{text superclasses}.  This
  18.299    introduces a locale @{text c} with import of all locales @{text
  18.300    superclasses}.
  18.301 @@ -990,7 +990,7 @@
  18.302    --- the @{method intro_classes} method takes care of the details of
  18.303    class membership proofs.
  18.304  
  18.305 -  \item @{command "instantiation"}~@{text "t :: (s\<^sub>1, \<dots>, s\<^sub>n)s
  18.306 +  \<^descr> @{command "instantiation"}~@{text "t :: (s\<^sub>1, \<dots>, s\<^sub>n)s
  18.307    \<BEGIN>"} opens a target (cf.\ \secref{sec:target}) which
  18.308    allows to specify class operations @{text "f\<^sub>1, \<dots>, f\<^sub>n"} corresponding
  18.309    to sort @{text s} at the particular type instance @{text "(\<alpha>\<^sub>1 :: s\<^sub>1,
  18.310 @@ -1002,7 +1002,7 @@
  18.311    this corresponds nicely to mutually recursive type definitions, e.g.\
  18.312    in Isabelle/HOL.
  18.313  
  18.314 -  \item @{command "instance"} in an instantiation target body sets
  18.315 +  \<^descr> @{command "instance"} in an instantiation target body sets
  18.316    up a goal stating the type arities claimed at the opening @{command
  18.317    "instantiation"}.  The proof would usually proceed by @{method
  18.318    intro_classes}, and then establish the characteristic theorems of
  18.319 @@ -1014,7 +1014,7 @@
  18.320    need to specify operations: one can continue with the
  18.321    instantiation proof immediately.
  18.322  
  18.323 -  \item @{command "subclass"}~@{text c} in a class context for class
  18.324 +  \<^descr> @{command "subclass"}~@{text c} in a class context for class
  18.325    @{text d} sets up a goal stating that class @{text c} is logically
  18.326    contained in class @{text d}.  After finishing the proof, class
  18.327    @{text d} is proven to be subclass @{text c} and the locale @{text
  18.328 @@ -1027,10 +1027,10 @@
  18.329    the logical connection are not sufficient on the locale level but on
  18.330    the theory level.
  18.331  
  18.332 -  \item @{command "print_classes"} prints all classes in the current
  18.333 +  \<^descr> @{command "print_classes"} prints all classes in the current
  18.334    theory.
  18.335  
  18.336 -  \item @{command "class_deps"} visualizes classes and their subclass
  18.337 +  \<^descr> @{command "class_deps"} visualizes classes and their subclass
  18.338    relations as a directed acyclic graph. By default, all classes from the
  18.339    current theory context are show. This may be restricted by optional bounds
  18.340    as follows: @{command "class_deps"}~@{text upper} or @{command
  18.341 @@ -1038,7 +1038,7 @@
  18.342    subclass of some sort from @{text upper} and a superclass of some sort
  18.343    from @{text lower}.
  18.344  
  18.345 -  \item @{method intro_classes} repeatedly expands all class
  18.346 +  \<^descr> @{method intro_classes} repeatedly expands all class
  18.347    introduction rules of this theory.  Note that this method usually
  18.348    needs not be named explicitly, as it is already included in the
  18.349    default proof step (e.g.\ of @{command "proof"}).  In particular,
  18.350 @@ -1143,7 +1143,7 @@
  18.351  
  18.352    \begin{description}
  18.353  
  18.354 -  \item @{command "overloading"}~@{text "x\<^sub>1 \<equiv> c\<^sub>1 :: \<tau>\<^sub>1 \<AND> \<dots> x\<^sub>n \<equiv> c\<^sub>n :: \<tau>\<^sub>n \<BEGIN>"}
  18.355 +  \<^descr> @{command "overloading"}~@{text "x\<^sub>1 \<equiv> c\<^sub>1 :: \<tau>\<^sub>1 \<AND> \<dots> x\<^sub>n \<equiv> c\<^sub>n :: \<tau>\<^sub>n \<BEGIN>"}
  18.356    opens a theory target (cf.\ \secref{sec:target}) which allows to
  18.357    specify constants with overloaded definitions.  These are identified
  18.358    by an explicitly given mapping from variable names @{text "x\<^sub>i"} to
  18.359 @@ -1194,7 +1194,7 @@
  18.360  
  18.361    \begin{description}
  18.362  
  18.363 -  \item @{command "SML_file"}~@{text "name"} reads and evaluates the
  18.364 +  \<^descr> @{command "SML_file"}~@{text "name"} reads and evaluates the
  18.365    given Standard ML file.  Top-level SML bindings are stored within
  18.366    the theory context; the initial environment is restricted to the
  18.367    Standard ML implementation of Poly/ML, without the many add-ons of
  18.368 @@ -1202,41 +1202,41 @@
  18.369    build larger Standard ML projects, independently of the regular
  18.370    Isabelle/ML environment.
  18.371  
  18.372 -  \item @{command "ML_file"}~@{text "name"} reads and evaluates the
  18.373 +  \<^descr> @{command "ML_file"}~@{text "name"} reads and evaluates the
  18.374    given ML file.  The current theory context is passed down to the ML
  18.375    toplevel and may be modified, using @{ML "Context.>>"} or derived ML
  18.376    commands.  Top-level ML bindings are stored within the (global or
  18.377    local) theory context.
  18.378    
  18.379 -  \item @{command "ML"}~@{text "text"} is similar to @{command
  18.380 +  \<^descr> @{command "ML"}~@{text "text"} is similar to @{command
  18.381    "ML_file"}, but evaluates directly the given @{text "text"}.
  18.382    Top-level ML bindings are stored within the (global or local) theory
  18.383    context.
  18.384  
  18.385 -  \item @{command "ML_prf"} is analogous to @{command "ML"} but works
  18.386 +  \<^descr> @{command "ML_prf"} is analogous to @{command "ML"} but works
  18.387    within a proof context.  Top-level ML bindings are stored within the
  18.388    proof context in a purely sequential fashion, disregarding the
  18.389    nested proof structure.  ML bindings introduced by @{command
  18.390    "ML_prf"} are discarded at the end of the proof.
  18.391  
  18.392 -  \item @{command "ML_val"} and @{command "ML_command"} are diagnostic
  18.393 +  \<^descr> @{command "ML_val"} and @{command "ML_command"} are diagnostic
  18.394    versions of @{command "ML"}, which means that the context may not be
  18.395    updated.  @{command "ML_val"} echos the bindings produced at the ML
  18.396    toplevel, but @{command "ML_command"} is silent.
  18.397    
  18.398 -  \item @{command "setup"}~@{text "text"} changes the current theory
  18.399 +  \<^descr> @{command "setup"}~@{text "text"} changes the current theory
  18.400    context by applying @{text "text"}, which refers to an ML expression
  18.401    of type @{ML_type "theory -> theory"}.  This enables to initialize
  18.402    any object-logic specific tools and packages written in ML, for
  18.403    example.
  18.404  
  18.405 -  \item @{command "local_setup"} is similar to @{command "setup"} for
  18.406 +  \<^descr> @{command "local_setup"} is similar to @{command "setup"} for
  18.407    a local theory context, and an ML expression of type @{ML_type
  18.408    "local_theory -> local_theory"}.  This allows to
  18.409    invoke local theory specification packages without going through
  18.410    concrete outer syntax, for example.
  18.411  
  18.412 -  \item @{command "attribute_setup"}~@{text "name = text description"}
  18.413 +  \<^descr> @{command "attribute_setup"}~@{text "name = text description"}
  18.414    defines an attribute in the current context.  The given @{text
  18.415    "text"} has to be an ML expression of type
  18.416    @{ML_type "attribute context_parser"}, cf.\ basic parsers defined in
  18.417 @@ -1268,16 +1268,16 @@
  18.418  text \<open>
  18.419    \begin{description}
  18.420  
  18.421 -  \item @{attribute ML_print_depth} controls the printing depth of the ML
  18.422 +  \<^descr> @{attribute ML_print_depth} controls the printing depth of the ML
  18.423    toplevel pretty printer; the precise effect depends on the ML compiler and
  18.424    run-time system. Typically the limit should be less than 10. Bigger values
  18.425    such as 100--1000 are occasionally useful for debugging.
  18.426  
  18.427 -  \item @{attribute ML_source_trace} indicates whether the source text that
  18.428 +  \<^descr> @{attribute ML_source_trace} indicates whether the source text that
  18.429    is given to the ML compiler should be output: it shows the raw Standard ML
  18.430    after expansion of Isabelle/ML antiquotations.
  18.431  
  18.432 -  \item @{attribute ML_exception_trace} indicates whether the ML run-time
  18.433 +  \<^descr> @{attribute ML_exception_trace} indicates whether the ML run-time
  18.434    system should print a detailed stack trace on exceptions. The result is
  18.435    dependent on the particular ML compiler version. Note that after Poly/ML
  18.436    5.3 some optimizations in the run-time systems may hinder exception
  18.437 @@ -1308,7 +1308,7 @@
  18.438  
  18.439    \begin{description}
  18.440  
  18.441 -  \item @{command "default_sort"}~@{text s} makes sort @{text s} the
  18.442 +  \<^descr> @{command "default_sort"}~@{text s} makes sort @{text s} the
  18.443    new default sort for any type variable that is given explicitly in
  18.444    the text, but lacks a sort constraint (wrt.\ the current context).
  18.445    Type variables generated by type inference are not affected.
  18.446 @@ -1341,13 +1341,13 @@
  18.447  
  18.448    \begin{description}
  18.449  
  18.450 -  \item @{command "type_synonym"}~@{text "(\<alpha>\<^sub>1, \<dots>, \<alpha>\<^sub>n) t = \<tau>"} introduces a
  18.451 +  \<^descr> @{command "type_synonym"}~@{text "(\<alpha>\<^sub>1, \<dots>, \<alpha>\<^sub>n) t = \<tau>"} introduces a
  18.452    \emph{type synonym} @{text "(\<alpha>\<^sub>1, \<dots>, \<alpha>\<^sub>n) t"} for the existing type @{text
  18.453    "\<tau>"}. Unlike the semantic type definitions in Isabelle/HOL, type synonyms
  18.454    are merely syntactic abbreviations without any logical significance.
  18.455    Internally, type synonyms are fully expanded.
  18.456    
  18.457 -  \item @{command "typedecl"}~@{text "(\<alpha>\<^sub>1, \<dots>, \<alpha>\<^sub>n) t"} declares a new
  18.458 +  \<^descr> @{command "typedecl"}~@{text "(\<alpha>\<^sub>1, \<dots>, \<alpha>\<^sub>n) t"} declares a new
  18.459    type constructor @{text t}.  If the object-logic defines a base sort
  18.460    @{text s}, then the constructor is declared to operate on that, via
  18.461    the axiomatic type-class instance @{text "t :: (s, \<dots>, s)s"}.
  18.462 @@ -1424,12 +1424,12 @@
  18.463  
  18.464    \begin{description}
  18.465  
  18.466 -  \item @{command "consts"}~@{text "c :: \<sigma>"} declares constant @{text
  18.467 +  \<^descr> @{command "consts"}~@{text "c :: \<sigma>"} declares constant @{text
  18.468    c} to have any instance of type scheme @{text \<sigma>}.  The optional
  18.469    mixfix annotations may attach concrete syntax to the constants
  18.470    declared.
  18.471    
  18.472 -  \item @{command "defs"}~@{text "name: eqn"} introduces @{text eqn}
  18.473 +  \<^descr> @{command "defs"}~@{text "name: eqn"} introduces @{text eqn}
  18.474    as a definitional axiom for some existing constant.
  18.475    
  18.476    The @{text "(unchecked)"} option disables global dependency checks
  18.477 @@ -1463,13 +1463,13 @@
  18.478  
  18.479    \begin{description}
  18.480    
  18.481 -  \item @{command "lemmas"}~@{text "a = b\<^sub>1 \<dots> b\<^sub>n"}~@{keyword_def
  18.482 +  \<^descr> @{command "lemmas"}~@{text "a = b\<^sub>1 \<dots> b\<^sub>n"}~@{keyword_def
  18.483    "for"}~@{text "x\<^sub>1 \<dots> x\<^sub>m"} evaluates given facts (with attributes) in
  18.484    the current context, which may be augmented by local variables.
  18.485    Results are standardized before being stored, i.e.\ schematic
  18.486    variables are renamed to enforce index @{text "0"} uniformly.
  18.487  
  18.488 -  \item @{command "named_theorems"}~@{text "name description"} declares a
  18.489 +  \<^descr> @{command "named_theorems"}~@{text "name description"} declares a
  18.490    dynamic fact within the context. The same @{text name} is used to define
  18.491    an attribute with the usual @{text add}/@{text del} syntax (e.g.\ see
  18.492    \secref{sec:simp-rules}) to maintain the content incrementally, in
  18.493 @@ -1507,7 +1507,7 @@
  18.494  
  18.495    \begin{description}
  18.496  
  18.497 -  \item @{command "oracle"}~@{text "name = text"} turns the given ML
  18.498 +  \<^descr> @{command "oracle"}~@{text "name = text"} turns the given ML
  18.499    expression @{text "text"} of type @{ML_text "'a -> cterm"} into an
  18.500    ML function of type @{ML_text "'a -> thm"}, which is bound to the
  18.501    global identifier @{ML_text name}.  This acts like an infinitary
  18.502 @@ -1545,7 +1545,7 @@
  18.503  
  18.504    \begin{description}
  18.505  
  18.506 -  \item @{command "hide_class"}~@{text names} fully removes class
  18.507 +  \<^descr> @{command "hide_class"}~@{text names} fully removes class
  18.508    declarations from a given name space; with the @{text "(open)"}
  18.509    option, only the unqualified base name is hidden.
  18.510  
  18.511 @@ -1554,7 +1554,7 @@
  18.512    longer accessible to the user are printed with the special qualifier
  18.513    ``@{text "??"}'' prefixed to the full internal name.
  18.514  
  18.515 -  \item @{command "hide_type"}, @{command "hide_const"}, and @{command
  18.516 +  \<^descr> @{command "hide_type"}, @{command "hide_const"}, and @{command
  18.517    "hide_fact"} are similar to @{command "hide_class"}, but hide types,
  18.518    constants, and facts, respectively.
  18.519    
    19.1 --- a/src/Doc/JEdit/JEdit.thy	Wed Oct 14 15:06:42 2015 +0200
    19.2 +++ b/src/Doc/JEdit/JEdit.thy	Wed Oct 14 15:10:32 2015 +0200
    19.3 @@ -20,32 +20,32 @@
    19.4  
    19.5    \begin{description}
    19.6  
    19.7 -  \item [PIDE] is a general framework for Prover IDEs based on Isabelle/Scala.
    19.8 +  \<^descr>[PIDE] is a general framework for Prover IDEs based on Isabelle/Scala.
    19.9    It is built around a concept of parallel and asynchronous document
   19.10    processing, which is supported natively by the parallel proof engine that is
   19.11    implemented in Isabelle/ML. The traditional prover command loop is given up;
   19.12    instead there is direct support for editing of source text, with rich formal
   19.13    markup for GUI rendering.
   19.14  
   19.15 -  \item [Isabelle/ML] is the implementation and extension language of
   19.16 +  \<^descr>[Isabelle/ML] is the implementation and extension language of
   19.17    Isabelle, see also @{cite "isabelle-implementation"}. It is integrated
   19.18    into the logical context of Isabelle/Isar and allows to manipulate
   19.19    logical entities directly. Arbitrary add-on tools may be implemented
   19.20    for object-logics such as Isabelle/HOL.
   19.21  
   19.22 -  \item [Isabelle/Scala] is the system programming language of
   19.23 +  \<^descr>[Isabelle/Scala] is the system programming language of
   19.24    Isabelle. It extends the pure logical environment of Isabelle/ML
   19.25    towards the ``real world'' of graphical user interfaces, text
   19.26    editors, IDE frameworks, web services etc.  Special infrastructure
   19.27    allows to transfer algebraic datatypes and formatted text easily
   19.28    between ML and Scala, using asynchronous protocol commands.
   19.29  
   19.30 -  \item [jEdit] is a sophisticated text editor implemented in
   19.31 +  \<^descr>[jEdit] is a sophisticated text editor implemented in
   19.32    Java.\footnote{@{url "http://www.jedit.org"}} It is easily extensible
   19.33    by plugins written in languages that work on the JVM, e.g.\
   19.34    Scala\footnote{@{url "http://www.scala-lang.org"}}.
   19.35  
   19.36 -  \item [Isabelle/jEdit] is the main example application of the PIDE
   19.37 +  \<^descr>[Isabelle/jEdit] is the main example application of the PIDE
   19.38    framework and the default user-interface for Isabelle. It targets
   19.39    both beginners and experts. Technically, Isabelle/jEdit combines a
   19.40    slightly modified version of the jEdit code base with a special
   19.41 @@ -288,7 +288,7 @@
   19.42  
   19.43    \begin{description}
   19.44  
   19.45 -  \item[Linux:] The platform-independent \emph{Nimbus} is used by
   19.46 +  \<^descr>[Linux:] The platform-independent \emph{Nimbus} is used by
   19.47    default.
   19.48  
   19.49    \emph{GTK+} also works under the side-condition that the overall GTK theme
   19.50 @@ -300,10 +300,10 @@
   19.51    ``4K'' or ``UHD'' models), because the rendering by the external library is
   19.52    subject to global system settings for font scaling.}
   19.53  
   19.54 -  \item[Windows:] Regular \emph{Windows} is used by default, but
   19.55 +  \<^descr>[Windows:] Regular \emph{Windows} is used by default, but
   19.56    \emph{Windows Classic} also works.
   19.57  
   19.58 -  \item[Mac OS X:] Regular \emph{Mac OS X} is used by default.
   19.59 +  \<^descr>[Mac OS X:] Regular \emph{Mac OS X} is used by default.
   19.60  
   19.61    The bundled \emph{MacOSX} plugin provides various functions that are
   19.62    expected from applications on that particular platform: quit from menu or
   19.63 @@ -1156,14 +1156,14 @@
   19.64  
   19.65    \begin{description}
   19.66  
   19.67 -  \item[] @{verbatim "`"} (single ASCII back-quote) supports \emph{quotations}
   19.68 +  \<^descr> @{verbatim "`"} (single ASCII back-quote) supports \emph{quotations}
   19.69    via text cartouches. There are three selections, which are always presented
   19.70    in the same order and do not depend on any context information. The default
   19.71    choice produces a template ``@{text "\<open>\<box>\<close>"}'', where the box indicates the
   19.72    cursor position after insertion; the other choices help to repair the block
   19.73    structure of unbalanced text cartouches.
   19.74  
   19.75 -  \item[] @{verbatim "@{"} is completed to the template ``@{text "@{\<box>}"}'',
   19.76 +  \<^descr> @{verbatim "@{"} is completed to the template ``@{text "@{\<box>}"}'',
   19.77    where the box indicates the cursor position after insertion. Here it is
   19.78    convenient to use the wildcard ``@{verbatim __}'' or a more specific name
   19.79    prefix to let semantic completion of name-space entries propose
   19.80 @@ -1344,18 +1344,18 @@
   19.81  
   19.82    \begin{description}
   19.83  
   19.84 -  \item[Explicit completion] works via action @{action_ref
   19.85 +  \<^descr>[Explicit completion] works via action @{action_ref
   19.86    "isabelle.complete"} with keyboard shortcut @{verbatim "C+b"}. This
   19.87    overrides the shortcut for @{action_ref "complete-word"} in jEdit, but it is
   19.88    possible to restore the original jEdit keyboard mapping of @{action
   19.89    "complete-word"} via \emph{Global Options~/ Shortcuts} and invent a
   19.90    different one for @{action "isabelle.complete"}.
   19.91  
   19.92 -  \item[Explicit spell-checker completion] works via @{action_ref
   19.93 +  \<^descr>[Explicit spell-checker completion] works via @{action_ref
   19.94    "isabelle.complete-word"}, which is exposed in the jEdit context menu, if
   19.95    the mouse points to a word that the spell-checker can complete.
   19.96  
   19.97 -  \item[Implicit completion] works via regular keyboard input of the editor.
   19.98 +  \<^descr>[Implicit completion] works via regular keyboard input of the editor.
   19.99    It depends on further side-conditions:
  19.100  
  19.101    \begin{enumerate}
  19.102 @@ -1436,15 +1436,15 @@
  19.103  
  19.104    \begin{description}
  19.105  
  19.106 -  \item[No selection.] The original is removed and the replacement inserted,
  19.107 +  \<^descr>[No selection.] The original is removed and the replacement inserted,
  19.108    depending on the caret position.
  19.109  
  19.110 -  \item[Rectangular selection of zero width.] This special case is treated by
  19.111 +  \<^descr>[Rectangular selection of zero width.] This special case is treated by
  19.112    jEdit as ``tall caret'' and insertion of completion imitates its normal
  19.113    behaviour: separate copies of the replacement are inserted for each line of
  19.114    the selection.
  19.115  
  19.116 -  \item[Other rectangular selection or multiple selections.] Here the original
  19.117 +  \<^descr>[Other rectangular selection or multiple selections.] Here the original
  19.118    is removed and the replacement is inserted for each line (or segment) of the
  19.119    selection.
  19.120  
    20.1 --- a/src/Doc/System/Basics.thy	Wed Oct 14 15:06:42 2015 +0200
    20.2 +++ b/src/Doc/System/Basics.thy	Wed Oct 14 15:10:32 2015 +0200
    20.3 @@ -150,7 +150,7 @@
    20.4  
    20.5    \begin{description}
    20.6  
    20.7 -  \item[@{setting_def USER_HOME}@{text "\<^sup>*"}] Is the cross-platform
    20.8 +  \<^descr>[@{setting_def USER_HOME}@{text "\<^sup>*"}] Is the cross-platform
    20.9    user home directory.  On Unix systems this is usually the same as
   20.10    @{setting HOME}, but on Windows it is the regular home directory of
   20.11    the user, not the one of within the Cygwin root
   20.12 @@ -158,12 +158,12 @@
   20.13    its HOME should point to the @{file_unchecked "/home"} directory tree or the
   20.14    Windows user home.}
   20.15  
   20.16 -  \item[@{setting_def ISABELLE_HOME}@{text "\<^sup>*"}] is the location of the
   20.17 +  \<^descr>[@{setting_def ISABELLE_HOME}@{text "\<^sup>*"}] is the location of the
   20.18    top-level Isabelle distribution directory. This is automatically
   20.19    determined from the Isabelle executable that has been invoked.  Do
   20.20    not attempt to set @{setting ISABELLE_HOME} yourself from the shell!
   20.21    
   20.22 -  \item[@{setting_def ISABELLE_HOME_USER}] is the user-specific
   20.23 +  \<^descr>[@{setting_def ISABELLE_HOME_USER}] is the user-specific
   20.24    counterpart of @{setting ISABELLE_HOME}. The default value is
   20.25    relative to @{file_unchecked "$USER_HOME/.isabelle"}, under rare
   20.26    circumstances this may be changed in the global setting file.
   20.27 @@ -172,21 +172,21 @@
   20.28    defaults may be overridden by a private @{verbatim
   20.29    "$ISABELLE_HOME_USER/etc/settings"}.
   20.30  
   20.31 -  \item[@{setting_def ISABELLE_PLATFORM_FAMILY}@{text "\<^sup>*"}] is
   20.32 +  \<^descr>[@{setting_def ISABELLE_PLATFORM_FAMILY}@{text "\<^sup>*"}] is
   20.33    automatically set to the general platform family: @{verbatim linux},
   20.34    @{verbatim macos}, @{verbatim windows}.  Note that
   20.35    platform-dependent tools usually need to refer to the more specific
   20.36    identification according to @{setting ISABELLE_PLATFORM}, @{setting
   20.37    ISABELLE_PLATFORM32}, @{setting ISABELLE_PLATFORM64}.
   20.38  
   20.39 -  \item[@{setting_def ISABELLE_PLATFORM}@{text "\<^sup>*"}] is automatically
   20.40 +  \<^descr>[@{setting_def ISABELLE_PLATFORM}@{text "\<^sup>*"}] is automatically
   20.41    set to a symbolic identifier for the underlying hardware and
   20.42    operating system.  The Isabelle platform identification always
   20.43    refers to the 32 bit variant, even this is a 64 bit machine.  Note
   20.44    that the ML or Java runtime may have a different idea, depending on
   20.45    which binaries are actually run.
   20.46  
   20.47 -  \item[@{setting_def ISABELLE_PLATFORM64}@{text "\<^sup>*"}] is similar to
   20.48 +  \<^descr>[@{setting_def ISABELLE_PLATFORM64}@{text "\<^sup>*"}] is similar to
   20.49    @{setting ISABELLE_PLATFORM} but refers to the proper 64 bit variant
   20.50    on a platform that supports this; the value is empty for 32 bit.
   20.51    Note that the following bash expression (including the quotes)
   20.52 @@ -194,18 +194,18 @@
   20.53  
   20.54    @{verbatim [display] \<open>"${ISABELLE_PLATFORM64:-$ISABELLE_PLATFORM}"\<close>}
   20.55  
   20.56 -  \item[@{setting_def ISABELLE_PROCESS}@{text "\<^sup>*"}, @{setting
   20.57 +  \<^descr>[@{setting_def ISABELLE_PROCESS}@{text "\<^sup>*"}, @{setting
   20.58    ISABELLE_TOOL}@{text "\<^sup>*"}] are automatically set to the full path
   20.59    names of the @{executable "isabelle_process"} and @{executable
   20.60    isabelle} executables, respectively.  Thus other tools and scripts
   20.61    need not assume that the @{file "$ISABELLE_HOME/bin"} directory is
   20.62    on the current search path of the shell.
   20.63    
   20.64 -  \item[@{setting_def ISABELLE_IDENTIFIER}@{text "\<^sup>*"}] refers
   20.65 +  \<^descr>[@{setting_def ISABELLE_IDENTIFIER}@{text "\<^sup>*"}] refers
   20.66    to the name of this Isabelle distribution, e.g.\ ``@{verbatim
   20.67    Isabelle2012}''.
   20.68  
   20.69 -  \item[@{setting_def ML_SYSTEM}, @{setting_def ML_HOME},
   20.70 +  \<^descr>[@{setting_def ML_SYSTEM}, @{setting_def ML_HOME},
   20.71    @{setting_def ML_OPTIONS}, @{setting_def ML_PLATFORM}, @{setting_def
   20.72    ML_IDENTIFIER}@{text "\<^sup>*"}] specify the underlying ML system
   20.73    to be used for Isabelle.  There is only a fixed set of admissable
   20.74 @@ -220,60 +220,60 @@
   20.75    automatically obtained by composing the values of @{setting
   20.76    ML_SYSTEM}, @{setting ML_PLATFORM} and the Isabelle version values.
   20.77  
   20.78 -  \item[@{setting_def ML_SYSTEM_POLYML}@{text "\<^sup>*"}] is @{verbatim true}
   20.79 +  \<^descr>[@{setting_def ML_SYSTEM_POLYML}@{text "\<^sup>*"}] is @{verbatim true}
   20.80    for @{setting ML_SYSTEM} values derived from Poly/ML, as opposed to
   20.81    SML/NJ where it is empty.  This is particularly useful with the
   20.82    build option @{system_option condition}
   20.83    (\secref{sec:system-options}) to restrict big sessions to something
   20.84    that SML/NJ can still handle.
   20.85  
   20.86 -  \item[@{setting_def ISABELLE_JDK_HOME}] needs to point to a full JDK
   20.87 +  \<^descr>[@{setting_def ISABELLE_JDK_HOME}] needs to point to a full JDK
   20.88    (Java Development Kit) installation with @{verbatim javac} and
   20.89    @{verbatim jar} executables.  This is essential for Isabelle/Scala
   20.90    and other JVM-based tools to work properly.  Note that conventional
   20.91    @{verbatim JAVA_HOME} usually points to the JRE (Java Runtime
   20.92    Environment), not JDK.
   20.93    
   20.94 -  \item[@{setting_def ISABELLE_PATH}] is a list of directories
   20.95 +  \<^descr>[@{setting_def ISABELLE_PATH}] is a list of directories
   20.96    (separated by colons) where Isabelle logic images may reside.  When
   20.97    looking up heaps files, the value of @{setting ML_IDENTIFIER} is
   20.98    appended to each component internally.
   20.99    
  20.100 -  \item[@{setting_def ISABELLE_OUTPUT}@{text "\<^sup>*"}] is a
  20.101 +  \<^descr>[@{setting_def ISABELLE_OUTPUT}@{text "\<^sup>*"}] is a
  20.102    directory where output heap files should be stored by default. The
  20.103    ML system and Isabelle version identifier is appended here, too.
  20.104    
  20.105 -  \item[@{setting_def ISABELLE_BROWSER_INFO}] is the directory where
  20.106 +  \<^descr>[@{setting_def ISABELLE_BROWSER_INFO}] is the directory where
  20.107    theory browser information (HTML text, graph data, and printable
  20.108    documents) is stored (see also \secref{sec:info}).  The default
  20.109    value is @{file_unchecked "$ISABELLE_HOME_USER/browser_info"}.
  20.110    
  20.111 -  \item[@{setting_def ISABELLE_LOGIC}] specifies the default logic to
  20.112 +  \<^descr>[@{setting_def ISABELLE_LOGIC}] specifies the default logic to
  20.113    load if none is given explicitely by the user.  The default value is
  20.114    @{verbatim HOL}.
  20.115    
  20.116 -  \item[@{setting_def ISABELLE_LINE_EDITOR}] specifies the
  20.117 +  \<^descr>[@{setting_def ISABELLE_LINE_EDITOR}] specifies the
  20.118    line editor for the @{tool_ref console} interface.
  20.119  
  20.120 -  \item[@{setting_def ISABELLE_LATEX}, @{setting_def
  20.121 +  \<^descr>[@{setting_def ISABELLE_LATEX}, @{setting_def
  20.122    ISABELLE_PDFLATEX}, @{setting_def ISABELLE_BIBTEX}] refer to {\LaTeX}
  20.123    related tools for Isabelle document preparation (see also
  20.124    \secref{sec:tool-latex}).
  20.125    
  20.126 -  \item[@{setting_def ISABELLE_TOOLS}] is a colon separated list of
  20.127 +  \<^descr>[@{setting_def ISABELLE_TOOLS}] is a colon separated list of
  20.128    directories that are scanned by @{executable isabelle} for external
  20.129    utility programs (see also \secref{sec:isabelle-tool}).
  20.130    
  20.131 -  \item[@{setting_def ISABELLE_DOCS}] is a colon separated list of
  20.132 +  \<^descr>[@{setting_def ISABELLE_DOCS}] is a colon separated list of
  20.133    directories with documentation files.
  20.134  
  20.135 -  \item[@{setting_def PDF_VIEWER}] specifies the program to be used
  20.136 +  \<^descr>[@{setting_def PDF_VIEWER}] specifies the program to be used
  20.137    for displaying @{verbatim pdf} files.
  20.138  
  20.139 -  \item[@{setting_def DVI_VIEWER}] specifies the program to be used
  20.140 +  \<^descr>[@{setting_def DVI_VIEWER}] specifies the program to be used
  20.141    for displaying @{verbatim dvi} files.
  20.142    
  20.143 -  \item[@{setting_def ISABELLE_TMP_PREFIX}@{text "\<^sup>*"}] is the
  20.144 +  \<^descr>[@{setting_def ISABELLE_TMP_PREFIX}@{text "\<^sup>*"}] is the
  20.145    prefix from which any running @{executable "isabelle_process"}
  20.146    derives an individual directory for temporary files.
  20.147    
    21.1 --- a/src/Doc/System/Misc.thy	Wed Oct 14 15:06:42 2015 +0200
    21.2 +++ b/src/Doc/System/Misc.thy	Wed Oct 14 15:10:32 2015 +0200
    21.3 @@ -126,17 +126,17 @@
    21.4  
    21.5    \begin{description}
    21.6  
    21.7 -  \item[Open \dots] Open a new graph file.
    21.8 +  \<^descr>[Open \dots] Open a new graph file.
    21.9  
   21.10 -  \item[Export to PostScript] Outputs the current graph in Postscript
   21.11 +  \<^descr>[Export to PostScript] Outputs the current graph in Postscript
   21.12    format, appropriately scaled to fit on one single sheet of A4 paper.
   21.13    The resulting file can be printed directly.
   21.14  
   21.15 -  \item[Export to EPS] Outputs the current graph in Encapsulated
   21.16 +  \<^descr>[Export to EPS] Outputs the current graph in Encapsulated
   21.17    Postscript format. The resulting file can be included in other
   21.18    documents.
   21.19  
   21.20 -  \item[Quit] Quit the graph browser.
   21.21 +  \<^descr>[Quit] Quit the graph browser.
   21.22  
   21.23    \end{description}
   21.24  \<close>
   21.25 @@ -158,21 +158,21 @@
   21.26  
   21.27    \begin{description}
   21.28  
   21.29 -  \item[@{text vertex_name}] The name of the vertex.
   21.30 +  \<^descr>[@{text vertex_name}] The name of the vertex.
   21.31  
   21.32 -  \item[@{text vertex_ID}] The vertex identifier. Note that there may
   21.33 +  \<^descr>[@{text vertex_ID}] The vertex identifier. Note that there may
   21.34    be several vertices with equal names, whereas identifiers must be
   21.35    unique.
   21.36  
   21.37 -  \item[@{text dir_name}] The name of the ``directory'' the vertex
   21.38 +  \<^descr>[@{text dir_name}] The name of the ``directory'' the vertex
   21.39    should be placed in.  A ``@{verbatim "+"}'' sign after @{text
   21.40    dir_name} indicates that the nodes in the directory are initially
   21.41    visible. Directories are initially invisible by default.
   21.42  
   21.43 -  \item[@{text path}] The path of the corresponding theory file. This
   21.44 +  \<^descr>[@{text path}] The path of the corresponding theory file. This
   21.45    is specified relatively to the path of the graph definition file.
   21.46  
   21.47 -  \item[List of successor/predecessor nodes] A ``@{verbatim "<"}''
   21.48 +  \<^descr>[List of successor/predecessor nodes] A ``@{verbatim "<"}''
   21.49    sign before the list means that successor nodes are listed, a
   21.50    ``@{verbatim ">"}'' sign means that predecessor nodes are listed. If
   21.51    neither ``@{verbatim "<"}'' nor ``@{verbatim ">"}'' is found, the
    22.1 --- a/src/Doc/System/Sessions.thy	Wed Oct 14 15:06:42 2015 +0200
    22.2 +++ b/src/Doc/System/Sessions.thy	Wed Oct 14 15:10:32 2015 +0200
    22.3 @@ -79,7 +79,7 @@
    22.4  
    22.5    \begin{description}
    22.6  
    22.7 -  \item \isakeyword{session}~@{text "A = B + body"} defines a new
    22.8 +  \<^descr> \isakeyword{session}~@{text "A = B + body"} defines a new
    22.9    session @{text "A"} based on parent session @{text "B"}, with its
   22.10    content given in @{text body} (theories and auxiliary source files).
   22.11    Note that a parent (like @{text "HOL"}) is mandatory in practical
   22.12 @@ -90,7 +90,7 @@
   22.13    @{text "A"} should be sufficiently long and descriptive to stand on
   22.14    its own in a potentially large library.
   22.15  
   22.16 -  \item \isakeyword{session}~@{text "A (groups)"} indicates a
   22.17 +  \<^descr> \isakeyword{session}~@{text "A (groups)"} indicates a
   22.18    collection of groups where the new session is a member.  Group names
   22.19    are uninterpreted and merely follow certain conventions.  For
   22.20    example, the Isabelle distribution tags some important sessions by
   22.21 @@ -98,7 +98,7 @@
   22.22    their own conventions, but this requires some care to avoid clashes
   22.23    within this unchecked name space.
   22.24  
   22.25 -  \item \isakeyword{session}~@{text "A"}~\isakeyword{in}~@{text "dir"}
   22.26 +  \<^descr> \isakeyword{session}~@{text "A"}~\isakeyword{in}~@{text "dir"}
   22.27    specifies an explicit directory for this session; by default this is
   22.28    the current directory of the @{verbatim ROOT} file.
   22.29  
   22.30 @@ -106,30 +106,30 @@
   22.31    the session directory.  The prover process is run within the same as
   22.32    its current working directory.
   22.33  
   22.34 -  \item \isakeyword{description}~@{text "text"} is a free-form
   22.35 +  \<^descr> \isakeyword{description}~@{text "text"} is a free-form
   22.36    annotation for this session.
   22.37  
   22.38 -  \item \isakeyword{options}~@{text "[x = a, y = b, z]"} defines
   22.39 +  \<^descr> \isakeyword{options}~@{text "[x = a, y = b, z]"} defines
   22.40    separate options (\secref{sec:system-options}) that are used when
   22.41    processing this session, but \emph{without} propagation to child
   22.42    sessions.  Note that @{text "z"} abbreviates @{text "z = true"} for
   22.43    Boolean options.
   22.44  
   22.45 -  \item \isakeyword{theories}~@{text "options names"} specifies a
   22.46 +  \<^descr> \isakeyword{theories}~@{text "options names"} specifies a
   22.47    block of theories that are processed within an environment that is
   22.48    augmented by the given options, in addition to the global session
   22.49    options given before.  Any number of blocks of \isakeyword{theories}
   22.50    may be given.  Options are only active for each
   22.51    \isakeyword{theories} block separately.
   22.52  
   22.53 -  \item \isakeyword{files}~@{text "files"} lists additional source
   22.54 +  \<^descr> \isakeyword{files}~@{text "files"} lists additional source
   22.55    files that are involved in the processing of this session.  This
   22.56    should cover anything outside the formal content of the theory
   22.57    sources.  In contrast, files that are loaded formally
   22.58    within a theory, e.g.\ via @{command "ML_file"}, need not be
   22.59    declared again.
   22.60  
   22.61 -  \item \isakeyword{document_files}~@{text "("}\isakeyword{in}~@{text
   22.62 +  \<^descr> \isakeyword{document_files}~@{text "("}\isakeyword{in}~@{text
   22.63    "base_dir) files"} lists source files for document preparation,
   22.64    typically @{verbatim ".tex"} and @{verbatim ".sty"} for {\LaTeX}.
   22.65    Only these explicitly given files are copied from the base directory
   22.66 @@ -138,7 +138,7 @@
   22.67    structure of the @{text files} is preserved, which allows to
   22.68    reconstruct the original directory hierarchy of @{text "base_dir"}.
   22.69  
   22.70 -  \item \isakeyword{document_files}~@{text "files"} abbreviates
   22.71 +  \<^descr> \isakeyword{document_files}~@{text "files"} abbreviates
   22.72    \isakeyword{document_files}~@{text "("}\isakeyword{in}~@{text
   22.73    "document) files"}, i.e.\ document sources are taken from the base
   22.74    directory @{verbatim document} within the session root directory.