doc-src/HOL/HOL.tex
author wenzelm
Wed, 14 Nov 2001 18:44:27 +0100
changeset 12180 91c9f661b183
parent 11242 81fe09ce5fc9
child 12611 c44a9fecb518
permissions -rw-r--r--
inductive: removed con_defs;
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
     1
%% $Id$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
     2
\chapter{Higher-Order Logic}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
     3
\index{higher-order logic|(}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
     4
\index{HOL system@{\sc hol} system}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
     5
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
     6
The theory~\thydx{HOL} implements higher-order logic.  It is based on
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
     7
Gordon's~{\sc hol} system~\cite{mgordon-hol}, which itself is based on
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
     8
Church's original paper~\cite{church40}.  Andrews's book~\cite{andrews86} is a
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
     9
full description of the original Church-style higher-order logic.  Experience
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
    10
with the {\sc hol} system has demonstrated that higher-order logic is widely
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
    11
applicable in many areas of mathematics and computer science, not just
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
    12
hardware verification, {\sc hol}'s original \textit{raison d'{\^e}tre\/}.  It
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
    13
is weaker than ZF set theory but for most applications this does not matter.
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
    14
If you prefer {\ML} to Lisp, you will probably prefer HOL to~ZF.
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
    15
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
    16
The syntax of HOL\footnote{Earlier versions of Isabelle's HOL used a different
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
    17
  syntax.  Ancient releases of Isabelle included still another version of~HOL,
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
    18
  with explicit type inference rules~\cite{paulson-COLOG}.  This version no
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
    19
  longer exists, but \thydx{ZF} supports a similar style of reasoning.}
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
    20
follows $\lambda$-calculus and functional programming.  Function application
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
    21
is curried.  To apply the function~$f$ of type $\tau@1\To\tau@2\To\tau@3$ to
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
    22
the arguments~$a$ and~$b$ in HOL, you simply write $f\,a\,b$.  There is no
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
    23
`apply' operator as in \thydx{ZF}.  Note that $f(a,b)$ means ``$f$ applied to
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
    24
the pair $(a,b)$'' in HOL.  We write ordered pairs as $(a,b)$, not $\langle
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
    25
a,b\rangle$ as in ZF.
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
    26
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
    27
HOL has a distinct feel, compared with ZF and CTT.  It identifies object-level
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
    28
types with meta-level types, taking advantage of Isabelle's built-in
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
    29
type-checker.  It identifies object-level functions with meta-level functions,
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
    30
so it uses Isabelle's operations for abstraction and application.
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
    31
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
    32
These identifications allow Isabelle to support HOL particularly nicely, but
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
    33
they also mean that HOL requires more sophistication from the user --- in
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
    34
particular, an understanding of Isabelle's type system.  Beginners should work
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
    35
with \texttt{show_types} (or even \texttt{show_sorts}) set to \texttt{true}.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    36
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    37
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    38
\begin{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    39
\begin{constants}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    40
  \it name      &\it meta-type  & \it description \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    41
  \cdx{Trueprop}& $bool\To prop$                & coercion to $prop$\\
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
    42
  \cdx{Not}     & $bool\To bool$                & negation ($\lnot$) \\
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    43
  \cdx{True}    & $bool$                        & tautology ($\top$) \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    44
  \cdx{False}   & $bool$                        & absurdity ($\bot$) \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    45
  \cdx{If}      & $[bool,\alpha,\alpha]\To\alpha$ & conditional \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    46
  \cdx{Let}     & $[\alpha,\alpha\To\beta]\To\beta$ & let binder
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    47
\end{constants}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    48
\subcaption{Constants}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    49
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    50
\begin{constants}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    51
\index{"@@{\tt\at} symbol}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    52
\index{*"! symbol}\index{*"? symbol}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    53
\index{*"?"! symbol}\index{*"E"X"! symbol}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    54
  \it symbol &\it name     &\it meta-type & \it description \\
7245
65ccac4e1f3f eliminated HOL_quantifiers (replaced by "HOL" print mode);
wenzelm
parents: 7044
diff changeset
    55
  \sdx{SOME} or \tt\at & \cdx{Eps}  & $(\alpha\To bool)\To\alpha$ & 
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    56
        Hilbert description ($\varepsilon$) \\
7245
65ccac4e1f3f eliminated HOL_quantifiers (replaced by "HOL" print mode);
wenzelm
parents: 7044
diff changeset
    57
  \sdx{ALL} or {\tt!~} & \cdx{All}  & $(\alpha\To bool)\To bool$ & 
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    58
        universal quantifier ($\forall$) \\
7245
65ccac4e1f3f eliminated HOL_quantifiers (replaced by "HOL" print mode);
wenzelm
parents: 7044
diff changeset
    59
  \sdx{EX} or {\tt?~}  & \cdx{Ex}   & $(\alpha\To bool)\To bool$ & 
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    60
        existential quantifier ($\exists$) \\
7245
65ccac4e1f3f eliminated HOL_quantifiers (replaced by "HOL" print mode);
wenzelm
parents: 7044
diff changeset
    61
  \texttt{EX!} or {\tt?!} & \cdx{Ex1}  & $(\alpha\To bool)\To bool$ & 
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    62
        unique existence ($\exists!$)\\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    63
  \texttt{LEAST}  & \cdx{Least}  & $(\alpha::ord \To bool)\To\alpha$ & 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    64
        least element
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    65
\end{constants}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    66
\subcaption{Binders} 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    67
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    68
\begin{constants}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    69
\index{*"= symbol}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    70
\index{&@{\tt\&} symbol}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    71
\index{*"| symbol}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    72
\index{*"-"-"> symbol}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    73
  \it symbol    & \it meta-type & \it priority & \it description \\ 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    74
  \sdx{o}       & $[\beta\To\gamma,\alpha\To\beta]\To (\alpha\To\gamma)$ & 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    75
        Left 55 & composition ($\circ$) \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    76
  \tt =         & $[\alpha,\alpha]\To bool$ & Left 50 & equality ($=$) \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    77
  \tt <         & $[\alpha::ord,\alpha]\To bool$ & Left 50 & less than ($<$) \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    78
  \tt <=        & $[\alpha::ord,\alpha]\To bool$ & Left 50 & 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    79
                less than or equals ($\leq$)\\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    80
  \tt \&        & $[bool,bool]\To bool$ & Right 35 & conjunction ($\conj$) \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    81
  \tt |         & $[bool,bool]\To bool$ & Right 30 & disjunction ($\disj$) \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    82
  \tt -->       & $[bool,bool]\To bool$ & Right 25 & implication ($\imp$)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    83
\end{constants}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    84
\subcaption{Infixes}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    85
\caption{Syntax of \texttt{HOL}} \label{hol-constants}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    86
\end{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    87
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    88
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    89
\begin{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    90
\index{*let symbol}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    91
\index{*in symbol}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    92
\dquotes
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    93
\[\begin{array}{rclcl}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    94
    term & = & \hbox{expression of class~$term$} \\
7245
65ccac4e1f3f eliminated HOL_quantifiers (replaced by "HOL" print mode);
wenzelm
parents: 7044
diff changeset
    95
         & | & "SOME~" id " . " formula
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    96
         & | & "\at~" id " . " formula \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    97
         & | & 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    98
    \multicolumn{3}{l}{"let"~id~"="~term";"\dots";"~id~"="~term~"in"~term} \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
    99
         & | & 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   100
    \multicolumn{3}{l}{"if"~formula~"then"~term~"else"~term} \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   101
         & | & "LEAST"~ id " . " formula \\[2ex]
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   102
 formula & = & \hbox{expression of type~$bool$} \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   103
         & | & term " = " term \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   104
         & | & term " \ttilde= " term \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   105
         & | & term " < " term \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   106
         & | & term " <= " term \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   107
         & | & "\ttilde\ " formula \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   108
         & | & formula " \& " formula \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   109
         & | & formula " | " formula \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   110
         & | & formula " --> " formula \\
7245
65ccac4e1f3f eliminated HOL_quantifiers (replaced by "HOL" print mode);
wenzelm
parents: 7044
diff changeset
   111
         & | & "ALL~" id~id^* " . " formula
65ccac4e1f3f eliminated HOL_quantifiers (replaced by "HOL" print mode);
wenzelm
parents: 7044
diff changeset
   112
         & | & "!~~~" id~id^* " . " formula \\
65ccac4e1f3f eliminated HOL_quantifiers (replaced by "HOL" print mode);
wenzelm
parents: 7044
diff changeset
   113
         & | & "EX~~" id~id^* " . " formula 
65ccac4e1f3f eliminated HOL_quantifiers (replaced by "HOL" print mode);
wenzelm
parents: 7044
diff changeset
   114
         & | & "?~~~" id~id^* " . " formula \\
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   115
         & | & "EX!~" id~id^* " . " formula
7245
65ccac4e1f3f eliminated HOL_quantifiers (replaced by "HOL" print mode);
wenzelm
parents: 7044
diff changeset
   116
         & | & "?!~~" id~id^* " . " formula \\
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   117
  \end{array}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   118
\]
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   119
\caption{Full grammar for HOL} \label{hol-grammar}
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   120
\end{figure} 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   121
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   122
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   123
\section{Syntax}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   124
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   125
Figure~\ref{hol-constants} lists the constants (including infixes and
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   126
binders), while Fig.\ts\ref{hol-grammar} presents the grammar of
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   127
higher-order logic.  Note that $a$\verb|~=|$b$ is translated to
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
   128
$\lnot(a=b)$.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   129
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   130
\begin{warn}
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   131
  HOL has no if-and-only-if connective; logical equivalence is expressed using
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   132
  equality.  But equality has a high priority, as befitting a relation, while
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   133
  if-and-only-if typically has the lowest priority.  Thus, $\lnot\lnot P=P$
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   134
  abbreviates $\lnot\lnot (P=P)$ and not $(\lnot\lnot P)=P$.  When using $=$
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   135
  to mean logical equivalence, enclose both operands in parentheses.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   136
\end{warn}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   137
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   138
\subsection{Types and overloading}
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   139
The universal type class of higher-order terms is called~\cldx{term}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   140
By default, explicit type variables have class \cldx{term}.  In
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   141
particular the equality symbol and quantifiers are polymorphic over
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   142
class \texttt{term}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   143
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   144
The type of formulae, \tydx{bool}, belongs to class \cldx{term}; thus,
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   145
formulae are terms.  The built-in type~\tydx{fun}, which constructs
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   146
function types, is overloaded with arity {\tt(term,\thinspace
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   147
  term)\thinspace term}.  Thus, $\sigma\To\tau$ belongs to class~{\tt
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   148
  term} if $\sigma$ and~$\tau$ do, allowing quantification over
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   149
functions.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   150
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   151
HOL allows new types to be declared as subsets of existing types;
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   152
see~{\S}\ref{sec:HOL:Types}.  ML-like datatypes can also be declared; see
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   153
~{\S}\ref{sec:HOL:datatype}.
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   154
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   155
Several syntactic type classes --- \cldx{plus}, \cldx{minus},
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   156
\cldx{times} and
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   157
\cldx{power} --- permit overloading of the operators {\tt+},\index{*"+
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   158
  symbol} {\tt-}\index{*"- symbol}, {\tt*}.\index{*"* symbol} 
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   159
and \verb|^|.\index{^@\verb.^. symbol} 
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   160
%
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   161
They are overloaded to denote the obvious arithmetic operations on types
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   162
\tdx{nat}, \tdx{int} and~\tdx{real}. (With the \verb|^| operator, the
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   163
exponent always has type~\tdx{nat}.)  Non-arithmetic overloadings are also
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   164
done: the operator {\tt-} can denote set difference, while \verb|^| can
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   165
denote exponentiation of relations (iterated composition).  Unary minus is
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   166
also written as~{\tt-} and is overloaded like its 2-place counterpart; it even
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   167
can stand for set complement.
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   168
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   169
The constant \cdx{0} is also overloaded.  It serves as the zero element of
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   170
several types, of which the most important is \tdx{nat} (the natural
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   171
numbers).  The type class \cldx{plus_ac0} comprises all types for which 0
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   172
and~+ satisfy the laws $x+y=y+x$, $(x+y)+z = x+(y+z)$ and $0+x = x$.  These
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   173
types include the numeric ones \tdx{nat}, \tdx{int} and~\tdx{real} and also
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   174
multisets.  The summation operator \cdx{setsum} is available for all types in
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   175
this class. 
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   176
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   177
Theory \thydx{Ord} defines the syntactic class \cldx{ord} of order
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   178
signatures.  The relations $<$ and $\leq$ are polymorphic over this
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   179
class, as are the functions \cdx{mono}, \cdx{min} and \cdx{max}, and
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   180
the \cdx{LEAST} operator. \thydx{Ord} also defines a subclass
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   181
\cldx{order} of \cldx{ord} which axiomatizes the types that are partially
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   182
ordered with respect to~$\leq$.  A further subclass \cldx{linorder} of
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   183
\cldx{order} axiomatizes linear orderings.
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   184
For details, see the file \texttt{Ord.thy}.
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   185
                                          
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   186
If you state a goal containing overloaded functions, you may need to include
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   187
type constraints.  Type inference may otherwise make the goal more
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   188
polymorphic than you intended, with confusing results.  For example, the
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
   189
variables $i$, $j$ and $k$ in the goal $i \leq j \Imp i \leq j+k$ have type
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   190
$\alpha::\{ord,plus\}$, although you may have expected them to have some
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   191
numeric type, e.g. $nat$.  Instead you should have stated the goal as
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
   192
$(i::nat) \leq j \Imp i \leq j+k$, which causes all three variables to have
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   193
type $nat$.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   194
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   195
\begin{warn}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   196
  If resolution fails for no obvious reason, try setting
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   197
  \ttindex{show_types} to \texttt{true}, causing Isabelle to display
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   198
  types of terms.  Possibly set \ttindex{show_sorts} to \texttt{true} as
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   199
  well, causing Isabelle to display type classes and sorts.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   200
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   201
  \index{unification!incompleteness of}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   202
  Where function types are involved, Isabelle's unification code does not
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   203
  guarantee to find instantiations for type variables automatically.  Be
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   204
  prepared to use \ttindex{res_inst_tac} instead of \texttt{resolve_tac},
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   205
  possibly instantiating type variables.  Setting
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   206
  \ttindex{Unify.trace_types} to \texttt{true} causes Isabelle to report
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   207
  omitted search paths during unification.\index{tracing!of unification}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   208
\end{warn}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   209
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   210
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   211
\subsection{Binders}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   212
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   213
Hilbert's {\bf description} operator~$\varepsilon x. P[x]$ stands for some~$x$
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   214
satisfying~$P$, if such exists.  Since all terms in HOL denote something, a
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   215
description is always meaningful, but we do not know its value unless $P$
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   216
defines it uniquely.  We may write descriptions as \cdx{Eps}($\lambda x.
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   217
P[x]$) or use the syntax \hbox{\tt SOME~$x$.~$P[x]$}.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   218
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   219
Existential quantification is defined by
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   220
\[ \exists x. P~x \;\equiv\; P(\varepsilon x. P~x). \]
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   221
The unique existence quantifier, $\exists!x. P$, is defined in terms
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   222
of~$\exists$ and~$\forall$.  An Isabelle binder, it admits nested
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   223
quantifications.  For instance, $\exists!x\,y. P\,x\,y$ abbreviates
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   224
$\exists!x. \exists!y. P\,x\,y$; note that this does not mean that there
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   225
exists a unique pair $(x,y)$ satisfying~$P\,x\,y$.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   226
7245
65ccac4e1f3f eliminated HOL_quantifiers (replaced by "HOL" print mode);
wenzelm
parents: 7044
diff changeset
   227
\medskip
65ccac4e1f3f eliminated HOL_quantifiers (replaced by "HOL" print mode);
wenzelm
parents: 7044
diff changeset
   228
65ccac4e1f3f eliminated HOL_quantifiers (replaced by "HOL" print mode);
wenzelm
parents: 7044
diff changeset
   229
\index{*"! symbol}\index{*"? symbol}\index{HOL system@{\sc hol} system} The
65ccac4e1f3f eliminated HOL_quantifiers (replaced by "HOL" print mode);
wenzelm
parents: 7044
diff changeset
   230
basic Isabelle/HOL binders have two notations.  Apart from the usual
65ccac4e1f3f eliminated HOL_quantifiers (replaced by "HOL" print mode);
wenzelm
parents: 7044
diff changeset
   231
\texttt{ALL} and \texttt{EX} for $\forall$ and $\exists$, Isabelle/HOL also
65ccac4e1f3f eliminated HOL_quantifiers (replaced by "HOL" print mode);
wenzelm
parents: 7044
diff changeset
   232
supports the original notation of Gordon's {\sc hol} system: \texttt{!}\ 
65ccac4e1f3f eliminated HOL_quantifiers (replaced by "HOL" print mode);
wenzelm
parents: 7044
diff changeset
   233
and~\texttt{?}.  In the latter case, the existential quantifier \emph{must} be
65ccac4e1f3f eliminated HOL_quantifiers (replaced by "HOL" print mode);
wenzelm
parents: 7044
diff changeset
   234
followed by a space; thus {\tt?x} is an unknown, while \verb'? x. f x=y' is a
65ccac4e1f3f eliminated HOL_quantifiers (replaced by "HOL" print mode);
wenzelm
parents: 7044
diff changeset
   235
quantification.  Both notations are accepted for input.  The print mode
65ccac4e1f3f eliminated HOL_quantifiers (replaced by "HOL" print mode);
wenzelm
parents: 7044
diff changeset
   236
``\ttindexbold{HOL}'' governs the output notation.  If enabled (e.g.\ by
65ccac4e1f3f eliminated HOL_quantifiers (replaced by "HOL" print mode);
wenzelm
parents: 7044
diff changeset
   237
passing option \texttt{-m HOL} to the \texttt{isabelle} executable),
65ccac4e1f3f eliminated HOL_quantifiers (replaced by "HOL" print mode);
wenzelm
parents: 7044
diff changeset
   238
then~{\tt!}\ and~{\tt?}\ are displayed.
65ccac4e1f3f eliminated HOL_quantifiers (replaced by "HOL" print mode);
wenzelm
parents: 7044
diff changeset
   239
65ccac4e1f3f eliminated HOL_quantifiers (replaced by "HOL" print mode);
wenzelm
parents: 7044
diff changeset
   240
\medskip
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   241
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   242
If $\tau$ is a type of class \cldx{ord}, $P$ a formula and $x$ a
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   243
variable of type $\tau$, then the term \cdx{LEAST}~$x. P[x]$ is defined
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
   244
to be the least (w.r.t.\ $\leq$) $x$ such that $P~x$ holds (see
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   245
Fig.~\ref{hol-defs}).  The definition uses Hilbert's $\varepsilon$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   246
choice operator, so \texttt{Least} is always meaningful, but may yield
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   247
nothing useful in case there is not a unique least element satisfying
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   248
$P$.\footnote{Class $ord$ does not require much of its instances, so
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
   249
  $\leq$ need not be a well-ordering, not even an order at all!}
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   250
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   251
\medskip All these binders have priority 10.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   252
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   253
\begin{warn}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   254
The low priority of binders means that they need to be enclosed in
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   255
parenthesis when they occur in the context of other operations.  For example,
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   256
instead of $P \land \forall x. Q$ you need to write $P \land (\forall x. Q)$.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   257
\end{warn}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   258
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   259
6620
fc991461c7b9 pdf setup;
wenzelm
parents: 6592
diff changeset
   260
\subsection{The let and case constructions}
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   261
Local abbreviations can be introduced by a \texttt{let} construct whose
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   262
syntax appears in Fig.\ts\ref{hol-grammar}.  Internally it is translated into
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   263
the constant~\cdx{Let}.  It can be expanded by rewriting with its
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   264
definition, \tdx{Let_def}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   265
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   266
HOL also defines the basic syntax
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   267
\[\dquotes"case"~e~"of"~c@1~"=>"~e@1~"|" \dots "|"~c@n~"=>"~e@n\] 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   268
as a uniform means of expressing \texttt{case} constructs.  Therefore \texttt{case}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   269
and \sdx{of} are reserved words.  Initially, this is mere syntax and has no
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   270
logical meaning.  By declaring translations, you can cause instances of the
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   271
\texttt{case} construct to denote applications of particular case operators.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   272
This is what happens automatically for each \texttt{datatype} definition
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
   273
(see~{\S}\ref{sec:HOL:datatype}).
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   274
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   275
\begin{warn}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   276
Both \texttt{if} and \texttt{case} constructs have as low a priority as
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   277
quantifiers, which requires additional enclosing parentheses in the context
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   278
of most other operations.  For example, instead of $f~x = {\tt if\dots
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   279
then\dots else}\dots$ you need to write $f~x = ({\tt if\dots then\dots
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   280
else\dots})$.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   281
\end{warn}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   282
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   283
\section{Rules of inference}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   284
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   285
\begin{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   286
\begin{ttbox}\makeatother
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   287
\tdx{refl}          t = (t::'a)
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   288
\tdx{subst}         [| s = t; P s |] ==> P (t::'a)
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   289
\tdx{ext}           (!!x::'a. (f x :: 'b) = g x) ==> (\%x. f x) = (\%x. g x)
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   290
\tdx{impI}          (P ==> Q) ==> P-->Q
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   291
\tdx{mp}            [| P-->Q;  P |] ==> Q
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   292
\tdx{iff}           (P-->Q) --> (Q-->P) --> (P=Q)
9969
4753185f1dd2 renamed (most of...) the select rules
paulson
parents: 9695
diff changeset
   293
\tdx{someI}         P(x::'a) ==> P(@x. P x)
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   294
\tdx{True_or_False} (P=True) | (P=False)
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   295
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   296
\caption{The \texttt{HOL} rules} \label{hol-rules}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   297
\end{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   298
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   299
Figure~\ref{hol-rules} shows the primitive inference rules of~HOL, with
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   300
their~{\ML} names.  Some of the rules deserve additional comments:
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   301
\begin{ttdescription}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   302
\item[\tdx{ext}] expresses extensionality of functions.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   303
\item[\tdx{iff}] asserts that logically equivalent formulae are
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   304
  equal.
9969
4753185f1dd2 renamed (most of...) the select rules
paulson
parents: 9695
diff changeset
   305
\item[\tdx{someI}] gives the defining property of the Hilbert
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   306
  $\varepsilon$-operator.  It is a form of the Axiom of Choice.  The derived rule
9969
4753185f1dd2 renamed (most of...) the select rules
paulson
parents: 9695
diff changeset
   307
  \tdx{some_equality} (see below) is often easier to use.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   308
\item[\tdx{True_or_False}] makes the logic classical.\footnote{In
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   309
    fact, the $\varepsilon$-operator already makes the logic classical, as
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   310
    shown by Diaconescu; see Paulson~\cite{paulson-COLOG} for details.}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   311
\end{ttdescription}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   312
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   313
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   314
\begin{figure}\hfuzz=4pt%suppress "Overfull \hbox" message
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   315
\begin{ttbox}\makeatother
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   316
\tdx{True_def}   True     == ((\%x::bool. x)=(\%x. x))
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   317
\tdx{All_def}    All      == (\%P. P = (\%x. True))
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   318
\tdx{Ex_def}     Ex       == (\%P. P(@x. P x))
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   319
\tdx{False_def}  False    == (!P. P)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   320
\tdx{not_def}    not      == (\%P. P-->False)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   321
\tdx{and_def}    op &     == (\%P Q. !R. (P-->Q-->R) --> R)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   322
\tdx{or_def}     op |     == (\%P Q. !R. (P-->R) --> (Q-->R) --> R)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   323
\tdx{Ex1_def}    Ex1      == (\%P. ? x. P x & (! y. P y --> y=x))
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   324
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   325
\tdx{o_def}      op o     == (\%(f::'b=>'c) g x::'a. f(g x))
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   326
\tdx{if_def}     If P x y ==
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   327
              (\%P x y. @z::'a.(P=True --> z=x) & (P=False --> z=y))
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   328
\tdx{Let_def}    Let s f  == f s
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   329
\tdx{Least_def}  Least P  == @x. P(x) & (ALL y. P(y) --> x <= y)"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   330
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   331
\caption{The \texttt{HOL} definitions} \label{hol-defs}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   332
\end{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   333
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   334
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   335
HOL follows standard practice in higher-order logic: only a few connectives
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   336
are taken as primitive, with the remainder defined obscurely
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   337
(Fig.\ts\ref{hol-defs}).  Gordon's {\sc hol} system expresses the
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   338
corresponding definitions \cite[page~270]{mgordon-hol} using
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   339
object-equality~({\tt=}), which is possible because equality in higher-order
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   340
logic may equate formulae and even functions over formulae.  But theory~HOL,
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   341
like all other Isabelle theories, uses meta-equality~({\tt==}) for
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   342
definitions.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   343
\begin{warn}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   344
The definitions above should never be expanded and are shown for completeness
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   345
only.  Instead users should reason in terms of the derived rules shown below
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   346
or, better still, using high-level tactics
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
   347
(see~{\S}\ref{sec:HOL:generic-packages}).
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   348
\end{warn}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   349
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   350
Some of the rules mention type variables; for example, \texttt{refl}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   351
mentions the type variable~{\tt'a}.  This allows you to instantiate
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   352
type variables explicitly by calling \texttt{res_inst_tac}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   353
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   354
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   355
\begin{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   356
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   357
\tdx{sym}         s=t ==> t=s
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   358
\tdx{trans}       [| r=s; s=t |] ==> r=t
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   359
\tdx{ssubst}      [| t=s; P s |] ==> P t
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   360
\tdx{box_equals}  [| a=b;  a=c;  b=d |] ==> c=d  
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   361
\tdx{arg_cong}    x = y ==> f x = f y
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   362
\tdx{fun_cong}    f = g ==> f x = g x
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   363
\tdx{cong}        [| f = g; x = y |] ==> f x = g y
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   364
\tdx{not_sym}     t ~= s ==> s ~= t
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   365
\subcaption{Equality}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   366
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   367
\tdx{TrueI}       True 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   368
\tdx{FalseE}      False ==> P
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   369
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   370
\tdx{conjI}       [| P; Q |] ==> P&Q
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   371
\tdx{conjunct1}   [| P&Q |] ==> P
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   372
\tdx{conjunct2}   [| P&Q |] ==> Q 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   373
\tdx{conjE}       [| P&Q;  [| P; Q |] ==> R |] ==> R
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   374
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   375
\tdx{disjI1}      P ==> P|Q
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   376
\tdx{disjI2}      Q ==> P|Q
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   377
\tdx{disjE}       [| P | Q; P ==> R; Q ==> R |] ==> R
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   378
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   379
\tdx{notI}        (P ==> False) ==> ~ P
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   380
\tdx{notE}        [| ~ P;  P |] ==> R
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   381
\tdx{impE}        [| P-->Q;  P;  Q ==> R |] ==> R
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   382
\subcaption{Propositional logic}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   383
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   384
\tdx{iffI}        [| P ==> Q;  Q ==> P |] ==> P=Q
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   385
\tdx{iffD1}       [| P=Q; P |] ==> Q
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   386
\tdx{iffD2}       [| P=Q; Q |] ==> P
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   387
\tdx{iffE}        [| P=Q; [| P --> Q; Q --> P |] ==> R |] ==> R
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   388
%
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   389
%\tdx{eqTrueI}     P ==> P=True 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   390
%\tdx{eqTrueE}     P=True ==> P 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   391
\subcaption{Logical equivalence}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   392
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   393
\end{ttbox}
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   394
\caption{Derived rules for HOL} \label{hol-lemmas1}
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   395
\end{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   396
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   397
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   398
\begin{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   399
\begin{ttbox}\makeatother
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   400
\tdx{allI}      (!!x. P x) ==> !x. P x
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   401
\tdx{spec}      !x. P x ==> P x
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   402
\tdx{allE}      [| !x. P x;  P x ==> R |] ==> R
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   403
\tdx{all_dupE}  [| !x. P x;  [| P x; !x. P x |] ==> R |] ==> R
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   404
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   405
\tdx{exI}       P x ==> ? x. P x
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   406
\tdx{exE}       [| ? x. P x; !!x. P x ==> Q |] ==> Q
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   407
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   408
\tdx{ex1I}      [| P a;  !!x. P x ==> x=a |] ==> ?! x. P x
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   409
\tdx{ex1E}      [| ?! x. P x;  !!x. [| P x;  ! y. P y --> y=x |] ==> R 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   410
          |] ==> R
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   411
9969
4753185f1dd2 renamed (most of...) the select rules
paulson
parents: 9695
diff changeset
   412
\tdx{some_equality}   [| P a;  !!x. P x ==> x=a |] ==> (@x. P x) = a
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   413
\subcaption{Quantifiers and descriptions}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   414
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   415
\tdx{ccontr}          (~P ==> False) ==> P
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   416
\tdx{classical}       (~P ==> P) ==> P
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   417
\tdx{excluded_middle} ~P | P
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   418
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   419
\tdx{disjCI}       (~Q ==> P) ==> P|Q
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   420
\tdx{exCI}         (! x. ~ P x ==> P a) ==> ? x. P x
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   421
\tdx{impCE}        [| P-->Q; ~ P ==> R; Q ==> R |] ==> R
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   422
\tdx{iffCE}        [| P=Q;  [| P;Q |] ==> R;  [| ~P; ~Q |] ==> R |] ==> R
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   423
\tdx{notnotD}      ~~P ==> P
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   424
\tdx{swap}         ~P ==> (~Q ==> P) ==> Q
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   425
\subcaption{Classical logic}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   426
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   427
\tdx{if_P}         P ==> (if P then x else y) = x
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   428
\tdx{if_not_P}     ~ P ==> (if P then x else y) = y
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   429
\tdx{split_if}     P(if Q then x else y) = ((Q --> P x) & (~Q --> P y))
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   430
\subcaption{Conditionals}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   431
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   432
\caption{More derived rules} \label{hol-lemmas2}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   433
\end{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   434
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   435
Some derived rules are shown in Figures~\ref{hol-lemmas1}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   436
and~\ref{hol-lemmas2}, with their {\ML} names.  These include natural rules
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   437
for the logical connectives, as well as sequent-style elimination rules for
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   438
conjunctions, implications, and universal quantifiers.  
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   439
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   440
Note the equality rules: \tdx{ssubst} performs substitution in
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   441
backward proofs, while \tdx{box_equals} supports reasoning by
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   442
simplifying both sides of an equation.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   443
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   444
The following simple tactics are occasionally useful:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   445
\begin{ttdescription}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   446
\item[\ttindexbold{strip_tac} $i$] applies \texttt{allI} and \texttt{impI}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   447
  repeatedly to remove all outermost universal quantifiers and implications
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   448
  from subgoal $i$.
8443
0ed4b608ba4b renamed cases_tac to case_tac;
wenzelm
parents: 8424
diff changeset
   449
\item[\ttindexbold{case_tac} {\tt"}$P${\tt"} $i$] performs case distinction on
0ed4b608ba4b renamed cases_tac to case_tac;
wenzelm
parents: 8424
diff changeset
   450
  $P$ for subgoal $i$: the latter is replaced by two identical subgoals with
0ed4b608ba4b renamed cases_tac to case_tac;
wenzelm
parents: 8424
diff changeset
   451
  the added assumptions $P$ and $\lnot P$, respectively.
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
   452
\item[\ttindexbold{smp_tac} $j$ $i$] applies $j$ times \texttt{spec} and then
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
   453
  \texttt{mp} in subgoal $i$, which is typically useful when forward-chaining 
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
   454
  from an induction hypothesis. As a generalization of \texttt{mp_tac}, 
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
   455
  if there are assumptions $\forall \vec{x}. P \vec{x} \imp Q \vec{x}$ and 
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
   456
  $P \vec{a}$, ($\vec{x}$ being a vector of $j$ variables)
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
   457
  then it replaces the universally quantified implication by $Q \vec{a}$. 
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
   458
  It may instantiate unknowns. It fails if it can do nothing.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   459
\end{ttdescription}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   460
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   461
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   462
\begin{figure} 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   463
\begin{center}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   464
\begin{tabular}{rrr}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   465
  \it name      &\it meta-type  & \it description \\ 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   466
\index{{}@\verb'{}' symbol}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   467
  \verb|{}|     & $\alpha\,set$         & the empty set \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   468
  \cdx{insert}  & $[\alpha,\alpha\,set]\To \alpha\,set$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   469
        & insertion of element \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   470
  \cdx{Collect} & $(\alpha\To bool)\To\alpha\,set$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   471
        & comprehension \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   472
  \cdx{INTER} & $[\alpha\,set,\alpha\To\beta\,set]\To\beta\,set$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   473
        & intersection over a set\\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   474
  \cdx{UNION} & $[\alpha\,set,\alpha\To\beta\,set]\To\beta\,set$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   475
        & union over a set\\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   476
  \cdx{Inter} & $(\alpha\,set)set\To\alpha\,set$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   477
        &set of sets intersection \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   478
  \cdx{Union} & $(\alpha\,set)set\To\alpha\,set$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   479
        &set of sets union \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   480
  \cdx{Pow}   & $\alpha\,set \To (\alpha\,set)set$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   481
        & powerset \\[1ex]
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   482
  \cdx{range}   & $(\alpha\To\beta )\To\beta\,set$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   483
        & range of a function \\[1ex]
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   484
  \cdx{Ball}~~\cdx{Bex} & $[\alpha\,set,\alpha\To bool]\To bool$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   485
        & bounded quantifiers
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   486
\end{tabular}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   487
\end{center}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   488
\subcaption{Constants}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   489
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   490
\begin{center}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   491
\begin{tabular}{llrrr} 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   492
  \it symbol &\it name     &\it meta-type & \it priority & \it description \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   493
  \sdx{INT}  & \cdx{INTER1}  & $(\alpha\To\beta\,set)\To\beta\,set$ & 10 & 
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   494
        intersection\\
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   495
  \sdx{UN}  & \cdx{UNION1}  & $(\alpha\To\beta\,set)\To\beta\,set$ & 10 & 
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   496
        union 
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   497
\end{tabular}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   498
\end{center}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   499
\subcaption{Binders} 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   500
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   501
\begin{center}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   502
\index{*"`"` symbol}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   503
\index{*": symbol}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   504
\index{*"<"= symbol}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   505
\begin{tabular}{rrrr} 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   506
  \it symbol    & \it meta-type & \it priority & \it description \\ 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   507
  \tt ``        & $[\alpha\To\beta ,\alpha\,set]\To  \beta\,set$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   508
        & Left 90 & image \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   509
  \sdx{Int}     & $[\alpha\,set,\alpha\,set]\To\alpha\,set$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   510
        & Left 70 & intersection ($\int$) \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   511
  \sdx{Un}      & $[\alpha\,set,\alpha\,set]\To\alpha\,set$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   512
        & Left 65 & union ($\un$) \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   513
  \tt:          & $[\alpha ,\alpha\,set]\To bool$       
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   514
        & Left 50 & membership ($\in$) \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   515
  \tt <=        & $[\alpha\,set,\alpha\,set]\To bool$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   516
        & Left 50 & subset ($\subseteq$) 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   517
\end{tabular}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   518
\end{center}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   519
\subcaption{Infixes}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   520
\caption{Syntax of the theory \texttt{Set}} \label{hol-set-syntax}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   521
\end{figure} 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   522
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   523
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   524
\begin{figure} 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   525
\begin{center} \tt\frenchspacing
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   526
\index{*"! symbol}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   527
\begin{tabular}{rrr} 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   528
  \it external          & \it internal  & \it description \\ 
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   529
  $a$ \ttilde: $b$      & \ttilde($a$ : $b$)    & \rm not in\\
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   530
  {\ttlbrace}$a@1$, $\ldots${\ttrbrace}  &  insert $a@1$ $\ldots$ {\ttlbrace}{\ttrbrace} & \rm finite set \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   531
  {\ttlbrace}$x$. $P[x]${\ttrbrace}        &  Collect($\lambda x. P[x]$) &
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   532
        \rm comprehension \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   533
  \sdx{INT} $x$:$A$. $B[x]$      & INTER $A$ $\lambda x. B[x]$ &
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   534
        \rm intersection \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   535
  \sdx{UN}{\tt\ }  $x$:$A$. $B[x]$      & UNION $A$ $\lambda x. B[x]$ &
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   536
        \rm union \\
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   537
  \sdx{ALL} $x$:$A$.\ $P[x]$ or \texttt{!} $x$:$A$.\ $P[x]$ &
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   538
        Ball $A$ $\lambda x.\ P[x]$ & 
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   539
        \rm bounded $\forall$ \\
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   540
  \sdx{EX}{\tt\ } $x$:$A$.\ $P[x]$ or \texttt{?} $x$:$A$.\ $P[x]$ & 
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   541
        Bex $A$ $\lambda x.\ P[x]$ & \rm bounded $\exists$
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   542
\end{tabular}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   543
\end{center}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   544
\subcaption{Translations}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   545
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   546
\dquotes
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   547
\[\begin{array}{rclcl}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   548
    term & = & \hbox{other terms\ldots} \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   549
         & | & "{\ttlbrace}{\ttrbrace}" \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   550
         & | & "{\ttlbrace} " term\; ("," term)^* " {\ttrbrace}" \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   551
         & | & "{\ttlbrace} " id " . " formula " {\ttrbrace}" \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   552
         & | & term " `` " term \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   553
         & | & term " Int " term \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   554
         & | & term " Un " term \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   555
         & | & "INT~~"  id ":" term " . " term \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   556
         & | & "UN~~~"  id ":" term " . " term \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   557
         & | & "INT~~"  id~id^* " . " term \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   558
         & | & "UN~~~"  id~id^* " . " term \\[2ex]
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   559
 formula & = & \hbox{other formulae\ldots} \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   560
         & | & term " : " term \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   561
         & | & term " \ttilde: " term \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   562
         & | & term " <= " term \\
7245
65ccac4e1f3f eliminated HOL_quantifiers (replaced by "HOL" print mode);
wenzelm
parents: 7044
diff changeset
   563
         & | & "ALL " id ":" term " . " formula
65ccac4e1f3f eliminated HOL_quantifiers (replaced by "HOL" print mode);
wenzelm
parents: 7044
diff changeset
   564
         & | & "!~" id ":" term " . " formula \\
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   565
         & | & "EX~~" id ":" term " . " formula
7245
65ccac4e1f3f eliminated HOL_quantifiers (replaced by "HOL" print mode);
wenzelm
parents: 7044
diff changeset
   566
         & | & "?~" id ":" term " . " formula \\
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   567
  \end{array}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   568
\]
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   569
\subcaption{Full Grammar}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   570
\caption{Syntax of the theory \texttt{Set} (continued)} \label{hol-set-syntax2}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   571
\end{figure} 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   572
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   573
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   574
\section{A formulation of set theory}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   575
Historically, higher-order logic gives a foundation for Russell and
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   576
Whitehead's theory of classes.  Let us use modern terminology and call them
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   577
{\bf sets}, but note that these sets are distinct from those of ZF set theory,
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   578
and behave more like ZF classes.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   579
\begin{itemize}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   580
\item
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   581
Sets are given by predicates over some type~$\sigma$.  Types serve to
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   582
define universes for sets, but type-checking is still significant.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   583
\item
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   584
There is a universal set (for each type).  Thus, sets have complements, and
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   585
may be defined by absolute comprehension.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   586
\item
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   587
Although sets may contain other sets as elements, the containing set must
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   588
have a more complex type.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   589
\end{itemize}
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   590
Finite unions and intersections have the same behaviour in HOL as they do
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   591
in~ZF.  In HOL the intersection of the empty set is well-defined, denoting the
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   592
universal set for the given type.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   593
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   594
\subsection{Syntax of set theory}\index{*set type}
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   595
HOL's set theory is called \thydx{Set}.  The type $\alpha\,set$ is essentially
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   596
the same as $\alpha\To bool$.  The new type is defined for clarity and to
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   597
avoid complications involving function types in unification.  The isomorphisms
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   598
between the two types are declared explicitly.  They are very natural:
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   599
\texttt{Collect} maps $\alpha\To bool$ to $\alpha\,set$, while \hbox{\tt op :}
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   600
maps in the other direction (ignoring argument order).
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   601
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   602
Figure~\ref{hol-set-syntax} lists the constants, infixes, and syntax
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   603
translations.  Figure~\ref{hol-set-syntax2} presents the grammar of the new
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   604
constructs.  Infix operators include union and intersection ($A\un B$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   605
and $A\int B$), the subset and membership relations, and the image
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   606
operator~{\tt``}\@.  Note that $a$\verb|~:|$b$ is translated to
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
   607
$\lnot(a\in b)$.  
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   608
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   609
The $\{a@1,\ldots\}$ notation abbreviates finite sets constructed in
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   610
the obvious manner using~\texttt{insert} and~$\{\}$:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   611
\begin{eqnarray*}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   612
  \{a, b, c\} & \equiv &
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   613
  \texttt{insert} \, a \, ({\tt insert} \, b \, ({\tt insert} \, c \, \{\}))
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   614
\end{eqnarray*}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   615
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   616
The set \hbox{\tt{\ttlbrace}$x$.\ $P[x]${\ttrbrace}} consists of all $x$ (of
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   617
suitable type) that satisfy~$P[x]$, where $P[x]$ is a formula that may contain
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   618
free occurrences of~$x$.  This syntax expands to \cdx{Collect}$(\lambda x.
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   619
P[x])$.  It defines sets by absolute comprehension, which is impossible in~ZF;
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   620
the type of~$x$ implicitly restricts the comprehension.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   621
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   622
The set theory defines two {\bf bounded quantifiers}:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   623
\begin{eqnarray*}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   624
   \forall x\in A. P[x] &\hbox{abbreviates}& \forall x. x\in A\imp P[x] \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   625
   \exists x\in A. P[x] &\hbox{abbreviates}& \exists x. x\in A\conj P[x]
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   626
\end{eqnarray*}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   627
The constants~\cdx{Ball} and~\cdx{Bex} are defined
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   628
accordingly.  Instead of \texttt{Ball $A$ $P$} and \texttt{Bex $A$ $P$} we may
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   629
write\index{*"! symbol}\index{*"? symbol}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   630
\index{*ALL symbol}\index{*EX symbol} 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   631
%
7245
65ccac4e1f3f eliminated HOL_quantifiers (replaced by "HOL" print mode);
wenzelm
parents: 7044
diff changeset
   632
\hbox{\tt ALL~$x$:$A$.\ $P[x]$} and \hbox{\tt EX~$x$:$A$.\ $P[x]$}.  The
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   633
original notation of Gordon's {\sc hol} system is supported as well:
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   634
\texttt{!}\ and \texttt{?}.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   635
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   636
Unions and intersections over sets, namely $\bigcup@{x\in A}B[x]$ and
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   637
$\bigcap@{x\in A}B[x]$, are written 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   638
\sdx{UN}~\hbox{\tt$x$:$A$.\ $B[x]$} and
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   639
\sdx{INT}~\hbox{\tt$x$:$A$.\ $B[x]$}.  
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   640
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   641
Unions and intersections over types, namely $\bigcup@x B[x]$ and $\bigcap@x
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   642
B[x]$, are written \sdx{UN}~\hbox{\tt$x$.\ $B[x]$} and
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   643
\sdx{INT}~\hbox{\tt$x$.\ $B[x]$}.  They are equivalent to the previous
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   644
union and intersection operators when $A$ is the universal set.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   645
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   646
The operators $\bigcup A$ and $\bigcap A$ act upon sets of sets.  They are
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   647
not binders, but are equal to $\bigcup@{x\in A}x$ and $\bigcap@{x\in A}x$,
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   648
respectively.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   649
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   650
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   651
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   652
\begin{figure} \underscoreon
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   653
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   654
\tdx{mem_Collect_eq}    (a : {\ttlbrace}x. P x{\ttrbrace}) = P a
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   655
\tdx{Collect_mem_eq}    {\ttlbrace}x. x:A{\ttrbrace} = A
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   656
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   657
\tdx{empty_def}         {\ttlbrace}{\ttrbrace}          == {\ttlbrace}x. False{\ttrbrace}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   658
\tdx{insert_def}        insert a B  == {\ttlbrace}x. x=a{\ttrbrace} Un B
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   659
\tdx{Ball_def}          Ball A P    == ! x. x:A --> P x
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   660
\tdx{Bex_def}           Bex A P     == ? x. x:A & P x
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   661
\tdx{subset_def}        A <= B      == ! x:A. x:B
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   662
\tdx{Un_def}            A Un B      == {\ttlbrace}x. x:A | x:B{\ttrbrace}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   663
\tdx{Int_def}           A Int B     == {\ttlbrace}x. x:A & x:B{\ttrbrace}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   664
\tdx{set_diff_def}      A - B       == {\ttlbrace}x. x:A & x~:B{\ttrbrace}
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   665
\tdx{Compl_def}         -A          == {\ttlbrace}x. ~ x:A{\ttrbrace}
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   666
\tdx{INTER_def}         INTER A B   == {\ttlbrace}y. ! x:A. y: B x{\ttrbrace}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   667
\tdx{UNION_def}         UNION A B   == {\ttlbrace}y. ? x:A. y: B x{\ttrbrace}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   668
\tdx{INTER1_def}        INTER1 B    == INTER {\ttlbrace}x. True{\ttrbrace} B 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   669
\tdx{UNION1_def}        UNION1 B    == UNION {\ttlbrace}x. True{\ttrbrace} B 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   670
\tdx{Inter_def}         Inter S     == (INT x:S. x)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   671
\tdx{Union_def}         Union S     == (UN  x:S. x)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   672
\tdx{Pow_def}           Pow A       == {\ttlbrace}B. B <= A{\ttrbrace}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   673
\tdx{image_def}         f``A        == {\ttlbrace}y. ? x:A. y=f x{\ttrbrace}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   674
\tdx{range_def}         range f     == {\ttlbrace}y. ? x. y=f x{\ttrbrace}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   675
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   676
\caption{Rules of the theory \texttt{Set}} \label{hol-set-rules}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   677
\end{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   678
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   679
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   680
\begin{figure} \underscoreon
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   681
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   682
\tdx{CollectI}        [| P a |] ==> a : {\ttlbrace}x. P x{\ttrbrace}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   683
\tdx{CollectD}        [| a : {\ttlbrace}x. P x{\ttrbrace} |] ==> P a
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   684
\tdx{CollectE}        [| a : {\ttlbrace}x. P x{\ttrbrace};  P a ==> W |] ==> W
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   685
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   686
\tdx{ballI}           [| !!x. x:A ==> P x |] ==> ! x:A. P x
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   687
\tdx{bspec}           [| ! x:A. P x;  x:A |] ==> P x
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   688
\tdx{ballE}           [| ! x:A. P x;  P x ==> Q;  ~ x:A ==> Q |] ==> Q
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   689
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   690
\tdx{bexI}            [| P x;  x:A |] ==> ? x:A. P x
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   691
\tdx{bexCI}           [| ! x:A. ~ P x ==> P a;  a:A |] ==> ? x:A. P x
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   692
\tdx{bexE}            [| ? x:A. P x;  !!x. [| x:A; P x |] ==> Q  |] ==> Q
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   693
\subcaption{Comprehension and Bounded quantifiers}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   694
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   695
\tdx{subsetI}         (!!x. x:A ==> x:B) ==> A <= B
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   696
\tdx{subsetD}         [| A <= B;  c:A |] ==> c:B
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   697
\tdx{subsetCE}        [| A <= B;  ~ (c:A) ==> P;  c:B ==> P |] ==> P
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   698
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   699
\tdx{subset_refl}     A <= A
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   700
\tdx{subset_trans}    [| A<=B;  B<=C |] ==> A<=C
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   701
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   702
\tdx{equalityI}       [| A <= B;  B <= A |] ==> A = B
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   703
\tdx{equalityD1}      A = B ==> A<=B
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   704
\tdx{equalityD2}      A = B ==> B<=A
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   705
\tdx{equalityE}       [| A = B;  [| A<=B; B<=A |] ==> P |]  ==>  P
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   706
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   707
\tdx{equalityCE}      [| A = B;  [| c:A; c:B |] ==> P;  
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   708
                           [| ~ c:A; ~ c:B |] ==> P 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   709
                |]  ==>  P
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   710
\subcaption{The subset and equality relations}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   711
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   712
\caption{Derived rules for set theory} \label{hol-set1}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   713
\end{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   714
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   715
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   716
\begin{figure} \underscoreon
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   717
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   718
\tdx{emptyE}   a : {\ttlbrace}{\ttrbrace} ==> P
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   719
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   720
\tdx{insertI1} a : insert a B
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   721
\tdx{insertI2} a : B ==> a : insert b B
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   722
\tdx{insertE}  [| a : insert b A;  a=b ==> P;  a:A ==> P |] ==> P
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   723
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   724
\tdx{ComplI}   [| c:A ==> False |] ==> c : -A
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   725
\tdx{ComplD}   [| c : -A |] ==> ~ c:A
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   726
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   727
\tdx{UnI1}     c:A ==> c : A Un B
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   728
\tdx{UnI2}     c:B ==> c : A Un B
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   729
\tdx{UnCI}     (~c:B ==> c:A) ==> c : A Un B
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   730
\tdx{UnE}      [| c : A Un B;  c:A ==> P;  c:B ==> P |] ==> P
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   731
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   732
\tdx{IntI}     [| c:A;  c:B |] ==> c : A Int B
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   733
\tdx{IntD1}    c : A Int B ==> c:A
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   734
\tdx{IntD2}    c : A Int B ==> c:B
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   735
\tdx{IntE}     [| c : A Int B;  [| c:A; c:B |] ==> P |] ==> P
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   736
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   737
\tdx{UN_I}     [| a:A;  b: B a |] ==> b: (UN x:A. B x)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   738
\tdx{UN_E}     [| b: (UN x:A. B x);  !!x.[| x:A;  b:B x |] ==> R |] ==> R
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   739
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   740
\tdx{INT_I}    (!!x. x:A ==> b: B x) ==> b : (INT x:A. B x)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   741
\tdx{INT_D}    [| b: (INT x:A. B x);  a:A |] ==> b: B a
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   742
\tdx{INT_E}    [| b: (INT x:A. B x);  b: B a ==> R;  ~ a:A ==> R |] ==> R
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   743
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   744
\tdx{UnionI}   [| X:C;  A:X |] ==> A : Union C
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   745
\tdx{UnionE}   [| A : Union C;  !!X.[| A:X;  X:C |] ==> R |] ==> R
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   746
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   747
\tdx{InterI}   [| !!X. X:C ==> A:X |] ==> A : Inter C
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   748
\tdx{InterD}   [| A : Inter C;  X:C |] ==> A:X
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   749
\tdx{InterE}   [| A : Inter C;  A:X ==> R;  ~ X:C ==> R |] ==> R
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   750
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   751
\tdx{PowI}     A<=B ==> A: Pow B
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   752
\tdx{PowD}     A: Pow B ==> A<=B
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   753
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   754
\tdx{imageI}   [| x:A |] ==> f x : f``A
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   755
\tdx{imageE}   [| b : f``A;  !!x.[| b=f x;  x:A |] ==> P |] ==> P
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   756
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   757
\tdx{rangeI}   f x : range f
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   758
\tdx{rangeE}   [| b : range f;  !!x.[| b=f x |] ==> P |] ==> P
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   759
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   760
\caption{Further derived rules for set theory} \label{hol-set2}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   761
\end{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   762
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   763
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   764
\subsection{Axioms and rules of set theory}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   765
Figure~\ref{hol-set-rules} presents the rules of theory \thydx{Set}.  The
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   766
axioms \tdx{mem_Collect_eq} and \tdx{Collect_mem_eq} assert
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   767
that the functions \texttt{Collect} and \hbox{\tt op :} are isomorphisms.  Of
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   768
course, \hbox{\tt op :} also serves as the membership relation.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   769
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   770
All the other axioms are definitions.  They include the empty set, bounded
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   771
quantifiers, unions, intersections, complements and the subset relation.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   772
They also include straightforward constructions on functions: image~({\tt``})
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   773
and \texttt{range}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   774
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   775
%The predicate \cdx{inj_on} is used for simulating type definitions.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   776
%The statement ${\tt inj_on}~f~A$ asserts that $f$ is injective on the
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   777
%set~$A$, which specifies a subset of its domain type.  In a type
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   778
%definition, $f$ is the abstraction function and $A$ is the set of valid
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   779
%representations; we should not expect $f$ to be injective outside of~$A$.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   780
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   781
%\begin{figure} \underscoreon
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   782
%\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   783
%\tdx{Inv_f_f}    inj f ==> Inv f (f x) = x
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   784
%\tdx{f_Inv_f}    y : range f ==> f(Inv f y) = y
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   785
%
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   786
%\tdx{Inv_injective}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   787
%    [| Inv f x=Inv f y; x: range f;  y: range f |] ==> x=y
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   788
%
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   789
%
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   790
%\tdx{monoI}      [| !!A B. A <= B ==> f A <= f B |] ==> mono f
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   791
%\tdx{monoD}      [| mono f;  A <= B |] ==> f A <= f B
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   792
%
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   793
%\tdx{injI}       [| !! x y. f x = f y ==> x=y |] ==> inj f
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   794
%\tdx{inj_inverseI}              (!!x. g(f x) = x) ==> inj f
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   795
%\tdx{injD}       [| inj f; f x = f y |] ==> x=y
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   796
%
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   797
%\tdx{inj_onI}  (!!x y. [| f x=f y; x:A; y:A |] ==> x=y) ==> inj_on f A
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   798
%\tdx{inj_onD}  [| inj_on f A;  f x=f y;  x:A;  y:A |] ==> x=y
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   799
%
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   800
%\tdx{inj_on_inverseI}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   801
%    (!!x. x:A ==> g(f x) = x) ==> inj_on f A
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   802
%\tdx{inj_on_contraD}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   803
%    [| inj_on f A;  x~=y;  x:A;  y:A |] ==> ~ f x=f y
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   804
%\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   805
%\caption{Derived rules involving functions} \label{hol-fun}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   806
%\end{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   807
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   808
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   809
\begin{figure} \underscoreon
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   810
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   811
\tdx{Union_upper}     B:A ==> B <= Union A
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   812
\tdx{Union_least}     [| !!X. X:A ==> X<=C |] ==> Union A <= C
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   813
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   814
\tdx{Inter_lower}     B:A ==> Inter A <= B
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   815
\tdx{Inter_greatest}  [| !!X. X:A ==> C<=X |] ==> C <= Inter A
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   816
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   817
\tdx{Un_upper1}       A <= A Un B
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   818
\tdx{Un_upper2}       B <= A Un B
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   819
\tdx{Un_least}        [| A<=C;  B<=C |] ==> A Un B <= C
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   820
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   821
\tdx{Int_lower1}      A Int B <= A
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   822
\tdx{Int_lower2}      A Int B <= B
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   823
\tdx{Int_greatest}    [| C<=A;  C<=B |] ==> C <= A Int B
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   824
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   825
\caption{Derived rules involving subsets} \label{hol-subset}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   826
\end{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   827
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   828
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   829
\begin{figure} \underscoreon   \hfuzz=4pt%suppress "Overfull \hbox" message
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   830
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   831
\tdx{Int_absorb}        A Int A = A
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   832
\tdx{Int_commute}       A Int B = B Int A
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   833
\tdx{Int_assoc}         (A Int B) Int C  =  A Int (B Int C)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   834
\tdx{Int_Un_distrib}    (A Un B)  Int C  =  (A Int C) Un (B Int C)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   835
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   836
\tdx{Un_absorb}         A Un A = A
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   837
\tdx{Un_commute}        A Un B = B Un A
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   838
\tdx{Un_assoc}          (A Un B)  Un C  =  A Un (B Un C)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   839
\tdx{Un_Int_distrib}    (A Int B) Un C  =  (A Un C) Int (B Un C)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   840
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   841
\tdx{Compl_disjoint}    A Int (-A) = {\ttlbrace}x. False{\ttrbrace}
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   842
\tdx{Compl_partition}   A Un  (-A) = {\ttlbrace}x. True{\ttrbrace}
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   843
\tdx{double_complement} -(-A) = A
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   844
\tdx{Compl_Un}          -(A Un B)  = (-A) Int (-B)
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   845
\tdx{Compl_Int}         -(A Int B) = (-A) Un (-B)
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   846
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   847
\tdx{Union_Un_distrib}  Union(A Un B) = (Union A) Un (Union B)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   848
\tdx{Int_Union}         A Int (Union B) = (UN C:B. A Int C)
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   849
%\tdx{Un_Union_image}    (UN x:C.(A x) Un (B x)) = Union(A``C) Un Union(B``C)
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   850
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   851
\tdx{Inter_Un_distrib}  Inter(A Un B) = (Inter A) Int (Inter B)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   852
\tdx{Un_Inter}          A Un (Inter B) = (INT C:B. A Un C)
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
   853
%\tdx{Int_Inter_image}   (INT x:C.(A x) Int (B x)) = Inter(A``C) Int Inter(B``C)
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   854
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   855
\caption{Set equalities} \label{hol-equalities}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   856
\end{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   857
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   858
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   859
Figures~\ref{hol-set1} and~\ref{hol-set2} present derived rules.  Most are
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   860
obvious and resemble rules of Isabelle's ZF set theory.  Certain rules, such
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   861
as \tdx{subsetCE}, \tdx{bexCI} and \tdx{UnCI}, are designed for classical
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   862
reasoning; the rules \tdx{subsetD}, \tdx{bexI}, \tdx{Un1} and~\tdx{Un2} are
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   863
not strictly necessary but yield more natural proofs.  Similarly,
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   864
\tdx{equalityCE} supports classical reasoning about extensionality, after the
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   865
fashion of \tdx{iffCE}.  See the file \texttt{HOL/Set.ML} for proofs
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   866
pertaining to set theory.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   867
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   868
Figure~\ref{hol-subset} presents lattice properties of the subset relation.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   869
Unions form least upper bounds; non-empty intersections form greatest lower
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   870
bounds.  Reasoning directly about subsets often yields clearer proofs than
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   871
reasoning about the membership relation.  See the file \texttt{HOL/subset.ML}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   872
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   873
Figure~\ref{hol-equalities} presents many common set equalities.  They
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   874
include commutative, associative and distributive laws involving unions,
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   875
intersections and complements.  For a complete listing see the file {\tt
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   876
HOL/equalities.ML}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   877
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   878
\begin{warn}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   879
\texttt{Blast_tac} proves many set-theoretic theorems automatically.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   880
Hence you seldom need to refer to the theorems above.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   881
\end{warn}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   882
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   883
\begin{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   884
\begin{center}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   885
\begin{tabular}{rrr}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   886
  \it name      &\it meta-type  & \it description \\ 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   887
  \cdx{inj}~~\cdx{surj}& $(\alpha\To\beta )\To bool$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   888
        & injective/surjective \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   889
  \cdx{inj_on}        & $[\alpha\To\beta ,\alpha\,set]\To bool$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   890
        & injective over subset\\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   891
  \cdx{inv} & $(\alpha\To\beta)\To(\beta\To\alpha)$ & inverse function
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   892
\end{tabular}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   893
\end{center}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   894
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   895
\underscoreon
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   896
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   897
\tdx{inj_def}         inj f      == ! x y. f x=f y --> x=y
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   898
\tdx{surj_def}        surj f     == ! y. ? x. y=f x
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   899
\tdx{inj_on_def}      inj_on f A == !x:A. !y:A. f x=f y --> x=y
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   900
\tdx{inv_def}         inv f      == (\%y. @x. f(x)=y)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   901
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   902
\caption{Theory \thydx{Fun}} \label{fig:HOL:Fun}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   903
\end{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   904
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   905
\subsection{Properties of functions}\nopagebreak
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   906
Figure~\ref{fig:HOL:Fun} presents a theory of simple properties of functions.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   907
Note that ${\tt inv}~f$ uses Hilbert's $\varepsilon$ to yield an inverse
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   908
of~$f$.  See the file \texttt{HOL/Fun.ML} for a complete listing of the derived
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   909
rules.  Reasoning about function composition (the operator~\sdx{o}) and the
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   910
predicate~\cdx{surj} is done simply by expanding the definitions.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   911
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   912
There is also a large collection of monotonicity theorems for constructions
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   913
on sets in the file \texttt{HOL/mono.ML}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   914
7283
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
   915
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   916
\section{Generic packages}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   917
\label{sec:HOL:generic-packages}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   918
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   919
HOL instantiates most of Isabelle's generic packages, making available the
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   920
simplifier and the classical reasoner.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   921
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   922
\subsection{Simplification and substitution}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   923
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   924
Simplification tactics tactics such as \texttt{Asm_simp_tac} and \texttt{Full_simp_tac} use the default simpset
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   925
(\texttt{simpset()}), which works for most purposes.  A quite minimal
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   926
simplification set for higher-order logic is~\ttindexbold{HOL_ss};
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   927
even more frugal is \ttindexbold{HOL_basic_ss}.  Equality~($=$), which
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   928
also expresses logical equivalence, may be used for rewriting.  See
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   929
the file \texttt{HOL/simpdata.ML} for a complete listing of the basic
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   930
simplification rules.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   931
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   932
See \iflabelundefined{chap:classical}{the {\em Reference Manual\/}}%
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   933
{Chaps.\ts\ref{substitution} and~\ref{simp-chap}} for details of substitution
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   934
and simplification.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   935
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   936
\begin{warn}\index{simplification!of conjunctions}%
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   937
  Reducing $a=b\conj P(a)$ to $a=b\conj P(b)$ is sometimes advantageous.  The
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   938
  left part of a conjunction helps in simplifying the right part.  This effect
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   939
  is not available by default: it can be slow.  It can be obtained by
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   940
  including \ttindex{conj_cong} in a simpset, \verb$addcongs [conj_cong]$.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   941
\end{warn}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   942
8604
c99e0024050c *** empty log message ***
nipkow
parents: 8443
diff changeset
   943
\begin{warn}\index{simplification!of \texttt{if}}\label{if-simp}%
c99e0024050c *** empty log message ***
nipkow
parents: 8443
diff changeset
   944
  By default only the condition of an \ttindex{if} is simplified but not the
c99e0024050c *** empty log message ***
nipkow
parents: 8443
diff changeset
   945
  \texttt{then} and \texttt{else} parts. Of course the latter are simplified
c99e0024050c *** empty log message ***
nipkow
parents: 8443
diff changeset
   946
  once the condition simplifies to \texttt{True} or \texttt{False}. To ensure
c99e0024050c *** empty log message ***
nipkow
parents: 8443
diff changeset
   947
  full simplification of all parts of a conditional you must remove
c99e0024050c *** empty log message ***
nipkow
parents: 8443
diff changeset
   948
  \ttindex{if_weak_cong} from the simpset, \verb$delcongs [if_weak_cong]$.
c99e0024050c *** empty log message ***
nipkow
parents: 8443
diff changeset
   949
\end{warn}
c99e0024050c *** empty log message ***
nipkow
parents: 8443
diff changeset
   950
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   951
If the simplifier cannot use a certain rewrite rule --- either because
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   952
of nontermination or because its left-hand side is too flexible ---
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   953
then you might try \texttt{stac}:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   954
\begin{ttdescription}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   955
\item[\ttindexbold{stac} $thm$ $i,$] where $thm$ is of the form $lhs = rhs$,
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   956
  replaces in subgoal $i$ instances of $lhs$ by corresponding instances of
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   957
  $rhs$.  In case of multiple instances of $lhs$ in subgoal $i$, backtracking
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   958
  may be necessary to select the desired ones.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   959
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   960
If $thm$ is a conditional equality, the instantiated condition becomes an
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   961
additional (first) subgoal.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   962
\end{ttdescription}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   963
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   964
HOL provides the tactic \ttindex{hyp_subst_tac}, which substitutes for an
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   965
equality throughout a subgoal and its hypotheses.  This tactic uses HOL's
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   966
general substitution rule.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   967
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   968
\subsubsection{Case splitting}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   969
\label{subsec:HOL:case:splitting}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   970
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   971
HOL also provides convenient means for case splitting during rewriting. Goals
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   972
containing a subterm of the form \texttt{if}~$b$~{\tt then\dots else\dots}
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   973
often require a case distinction on $b$. This is expressed by the theorem
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
   974
\tdx{split_if}:
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   975
$$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   976
\Var{P}(\mbox{\tt if}~\Var{b}~{\tt then}~\Var{x}~\mbox{\tt else}~\Var{y})~=~
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
   977
((\Var{b} \to \Var{P}(\Var{x})) \land (\lnot \Var{b} \to \Var{P}(\Var{y})))
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   978
\eqno{(*)}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   979
$$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   980
For example, a simple instance of $(*)$ is
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   981
\[
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   982
x \in (\mbox{\tt if}~x \in A~{\tt then}~A~\mbox{\tt else}~\{x\})~=~
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   983
((x \in A \to x \in A) \land (x \notin A \to x \in \{x\}))
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   984
\]
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   985
Because $(*)$ is too general as a rewrite rule for the simplifier (the
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   986
left-hand side is not a higher-order pattern in the sense of
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   987
\iflabelundefined{chap:simplification}{the {\em Reference Manual\/}}%
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   988
{Chap.\ts\ref{chap:simplification}}), there is a special infix function 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   989
\ttindexbold{addsplits} of type \texttt{simpset * thm list -> simpset}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   990
(analogous to \texttt{addsimps}) that adds rules such as $(*)$ to a
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   991
simpset, as in
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   992
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   993
by(simp_tac (simpset() addsplits [split_if]) 1);
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   994
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   995
The effect is that after each round of simplification, one occurrence of
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   996
\texttt{if} is split acording to \texttt{split_if}, until all occurences of
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   997
\texttt{if} have been eliminated.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   998
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
   999
It turns out that using \texttt{split_if} is almost always the right thing to
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1000
do. Hence \texttt{split_if} is already included in the default simpset. If
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1001
you want to delete it from a simpset, use \ttindexbold{delsplits}, which is
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1002
the inverse of \texttt{addsplits}:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1003
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1004
by(simp_tac (simpset() delsplits [split_if]) 1);
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1005
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1006
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1007
In general, \texttt{addsplits} accepts rules of the form
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1008
\[
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1009
\Var{P}(c~\Var{x@1}~\dots~\Var{x@n})~=~ rhs
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1010
\]
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1011
where $c$ is a constant and $rhs$ is arbitrary. Note that $(*)$ is of the
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1012
right form because internally the left-hand side is
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1013
$\Var{P}(\mathtt{If}~\Var{b}~\Var{x}~~\Var{y})$. Important further examples
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
  1014
are splitting rules for \texttt{case} expressions (see~{\S}\ref{subsec:list}
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
  1015
and~{\S}\ref{subsec:datatype:basics}).
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1016
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1017
Analogous to \texttt{Addsimps} and \texttt{Delsimps}, there are also
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1018
imperative versions of \texttt{addsplits} and \texttt{delsplits}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1019
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1020
\ttindexbold{Addsplits}: thm list -> unit
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1021
\ttindexbold{Delsplits}: thm list -> unit
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1022
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1023
for adding splitting rules to, and deleting them from the current simpset.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1024
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1025
\subsection{Classical reasoning}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1026
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  1027
HOL derives classical introduction rules for $\disj$ and~$\exists$, as well as
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  1028
classical elimination rules for~$\imp$ and~$\bimp$, and the swap rule; recall
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  1029
Fig.\ts\ref{hol-lemmas2} above.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1030
7283
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1031
The classical reasoner is installed.  Tactics such as \texttt{Blast_tac} and
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1032
{\tt Best_tac} refer to the default claset (\texttt{claset()}), which works
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1033
for most purposes.  Named clasets include \ttindexbold{prop_cs}, which
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1034
includes the propositional rules, and \ttindexbold{HOL_cs}, which also
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1035
includes quantifier rules.  See the file \texttt{HOL/cladata.ML} for lists of
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1036
the classical rules,
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1037
and \iflabelundefined{chap:classical}{the {\em Reference Manual\/}}%
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1038
{Chap.\ts\ref{chap:classical}} for more discussion of classical proof methods.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1039
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1040
7283
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1041
\section{Calling the decision procedure SVC}\label{sec:HOL:SVC}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1042
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1043
\index{SVC decision procedure|(}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1044
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1045
The Stanford Validity Checker (SVC) is a tool that can check the validity of
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1046
certain types of formulae.  If it is installed on your machine, then
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1047
Isabelle/HOL can be configured to call it through the tactic
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1048
\ttindex{svc_tac}.  It is ideal for large tautologies and complex problems in
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1049
linear arithmetic.  Subexpressions that SVC cannot handle are automatically
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1050
replaced by variables, so you can call the tactic on any subgoal.  See the
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1051
file \texttt{HOL/ex/svc_test.ML} for examples.
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1052
\begin{ttbox} 
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1053
svc_tac   : int -> tactic
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1054
Svc.trace : bool ref      \hfill{\bf initially false}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1055
\end{ttbox}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1056
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1057
\begin{ttdescription}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1058
\item[\ttindexbold{svc_tac} $i$] attempts to prove subgoal~$i$ by translating
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1059
  it into a formula recognized by~SVC\@.  If it succeeds then the subgoal is
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1060
  removed.  It fails if SVC is unable to prove the subgoal.  It crashes with
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1061
  an error message if SVC appears not to be installed.  Numeric variables may
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1062
  have types \texttt{nat}, \texttt{int} or \texttt{real}.
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1063
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1064
\item[\ttindexbold{Svc.trace}] is a flag that, if set, causes \texttt{svc_tac}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1065
  to trace its operations: abstraction of the subgoal, translation to SVC
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1066
  syntax, SVC's response.
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1067
\end{ttdescription}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1068
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1069
Here is an example, with tracing turned on:
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1070
\begin{ttbox}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1071
set Svc.trace;
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1072
{\out val it : bool = true}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1073
Goal "(#3::nat)*a <= #2 + #4*b + #6*c  & #11 <= #2*a + b + #2*c & \ttback
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1074
\ttback     a + #3*b <= #5 + #2*c  --> #2 + #3*b <= #2*a + #6*c";
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1075
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1076
by (svc_tac 1);
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1077
{\out Subgoal abstracted to}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1078
{\out #3 * a <= #2 + #4 * b + #6 * c &}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1079
{\out #11 <= #2 * a + b + #2 * c & a + #3 * b <= #5 + #2 * c -->}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1080
{\out #2 + #3 * b <= #2 * a + #6 * c}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1081
{\out Calling SVC:}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1082
{\out (=> (<= 0  (F_c) )  (=> (<= 0  (F_b) )  (=> (<= 0  (F_a) )}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1083
{\out   (=> (AND (<= {* 3  (F_a) }  {+ {+ 2  {* 4  (F_b) } }  }
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1084
{\out {* 6  (F_c) } } )  (AND (<= 11  {+ {+ {* 2  (F_a) }  (F_b) }}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1085
{\out   {* 2  (F_c) } } )  (<= {+ (F_a)  {* 3  (F_b) } }  {+ 5  }
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1086
{\out {* 2  (F_c) } } ) ) )  (< {+ 2  {* 3  (F_b) } }  {+ 1  {+ }
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1087
{\out {* 2  (F_a) }  {* 6  (F_c) } } } ) ) ) ) ) }
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1088
{\out SVC Returns:}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1089
{\out VALID}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1090
{\out Level 1}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1091
{\out #3 * a <= #2 + #4 * b + #6 * c &}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1092
{\out #11 <= #2 * a + b + #2 * c & a + #3 * b <= #5 + #2 * c -->}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1093
{\out #2 + #3 * b <= #2 * a + #6 * c}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1094
{\out No subgoals!}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1095
\end{ttbox}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1096
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1097
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1098
\begin{warn}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1099
Calling \ttindex{svc_tac} entails an above-average risk of
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1100
unsoundness.  Isabelle does not check SVC's result independently.  Moreover,
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1101
the tactic translates the submitted formula using code that lies outside
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1102
Isabelle's inference core.  Theorems that depend upon results proved using SVC
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1103
(and other oracles) are displayed with the annotation \texttt{[!]} attached.
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1104
You can also use \texttt{\#der (rep_thm $th$)} to examine the proof object of
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1105
theorem~$th$, as described in the \emph{Reference Manual}.  
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1106
\end{warn}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1107
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1108
To start, first download SVC from the Internet at URL
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1109
\begin{ttbox}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1110
http://agamemnon.stanford.edu/~levitt/vc/index.html
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1111
\end{ttbox}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1112
and install it using the instructions supplied.  SVC requires two environment
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1113
variables:
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1114
\begin{ttdescription}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1115
\item[\ttindexbold{SVC_HOME}] is an absolute pathname to the SVC
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1116
    distribution directory. 
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1117
    
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1118
  \item[\ttindexbold{SVC_MACHINE}] identifies the type of computer and
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1119
    operating system.  
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1120
\end{ttdescription}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1121
You can set these environment variables either using the Unix shell or through
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1122
an Isabelle \texttt{settings} file.  Isabelle assumes SVC to be installed if
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1123
\texttt{SVC_HOME} is defined.
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1124
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1125
\paragraph*{Acknowledgement.}  This interface uses code supplied by S{\o}ren
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1126
Heilmann.
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1127
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1128
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1129
\index{SVC decision procedure|)}
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1130
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1131
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1132
5cfe2944910a documented svc_tac
paulson
parents: 7245
diff changeset
  1133
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1134
\section{Types}\label{sec:HOL:Types}
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  1135
This section describes HOL's basic predefined types ($\alpha \times \beta$,
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  1136
$\alpha + \beta$, $nat$ and $\alpha \; list$) and ways for introducing new
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  1137
types in general.  The most important type construction, the
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  1138
\texttt{datatype}, is treated separately in {\S}\ref{sec:HOL:datatype}.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1139
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1140
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1141
\subsection{Product and sum types}\index{*"* type}\index{*"+ type}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1142
\label{subsec:prod-sum}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1143
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1144
\begin{figure}[htbp]
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1145
\begin{constants}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1146
  \it symbol    & \it meta-type &           & \it description \\ 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1147
  \cdx{Pair}    & $[\alpha,\beta]\To \alpha\times\beta$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1148
        & & ordered pairs $(a,b)$ \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1149
  \cdx{fst}     & $\alpha\times\beta \To \alpha$        & & first projection\\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1150
  \cdx{snd}     & $\alpha\times\beta \To \beta$         & & second projection\\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1151
  \cdx{split}   & $[[\alpha,\beta]\To\gamma, \alpha\times\beta] \To \gamma$ 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1152
        & & generalized projection\\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1153
  \cdx{Sigma}  & 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1154
        $[\alpha\,set, \alpha\To\beta\,set]\To(\alpha\times\beta)set$ &
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1155
        & general sum of sets
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1156
\end{constants}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1157
\begin{ttbox}\makeatletter
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1158
%\tdx{fst_def}      fst p     == @a. ? b. p = (a,b)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1159
%\tdx{snd_def}      snd p     == @b. ? a. p = (a,b)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1160
%\tdx{split_def}    split c p == c (fst p) (snd p)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1161
\tdx{Sigma_def}    Sigma A B == UN x:A. UN y:B x. {\ttlbrace}(x,y){\ttrbrace}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1162
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1163
\tdx{Pair_eq}      ((a,b) = (a',b')) = (a=a' & b=b')
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1164
\tdx{Pair_inject}  [| (a, b) = (a',b');  [| a=a';  b=b' |] ==> R |] ==> R
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1165
\tdx{PairE}        [| !!x y. p = (x,y) ==> Q |] ==> Q
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1166
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1167
\tdx{fst_conv}     fst (a,b) = a
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1168
\tdx{snd_conv}     snd (a,b) = b
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1169
\tdx{surjective_pairing}  p = (fst p,snd p)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1170
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1171
\tdx{split}        split c (a,b) = c a b
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1172
\tdx{split_split}  R(split c p) = (! x y. p = (x,y) --> R(c x y))
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1173
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1174
\tdx{SigmaI}    [| a:A;  b:B a |] ==> (a,b) : Sigma A B
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1175
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1176
\tdx{SigmaE}    [| c:Sigma A B; !!x y.[| x:A; y:B x; c=(x,y) |] ==> P 
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1177
          |] ==> P
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1178
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1179
\caption{Type $\alpha\times\beta$}\label{hol-prod}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1180
\end{figure} 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1181
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1182
Theory \thydx{Prod} (Fig.\ts\ref{hol-prod}) defines the product type
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1183
$\alpha\times\beta$, with the ordered pair syntax $(a, b)$.  General
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1184
tuples are simulated by pairs nested to the right:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1185
\begin{center}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1186
\begin{tabular}{c|c}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1187
external & internal \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1188
\hline
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1189
$\tau@1 \times \dots \times \tau@n$ & $\tau@1 \times (\dots (\tau@{n-1} \times \tau@n)\dots)$ \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1190
\hline
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1191
$(t@1,\dots,t@n)$ & $(t@1,(\dots,(t@{n-1},t@n)\dots)$ \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1192
\end{tabular}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1193
\end{center}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1194
In addition, it is possible to use tuples
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1195
as patterns in abstractions:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1196
\begin{center}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1197
{\tt\%($x$,$y$). $t$} \quad stands for\quad \texttt{split(\%$x$\thinspace$y$.\ $t$)} 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1198
\end{center}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1199
Nested patterns are also supported.  They are translated stepwise:
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1200
\begin{eqnarray*}
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1201
\hbox{\tt\%($x$,$y$,$z$).\ $t$} 
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1202
   & \leadsto & \hbox{\tt\%($x$,($y$,$z$)).\ $t$} \\
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1203
   & \leadsto & \hbox{\tt split(\%$x$.\%($y$,$z$).\ $t$)}\\
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1204
   & \leadsto & \hbox{\tt split(\%$x$.\ split(\%$y$ $z$.\ $t$))}
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1205
\end{eqnarray*}
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1206
The reverse translation is performed upon printing.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1207
\begin{warn}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1208
  The translation between patterns and \texttt{split} is performed automatically
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1209
  by the parser and printer.  Thus the internal and external form of a term
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1210
  may differ, which can affects proofs.  For example the term {\tt
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1211
  (\%(x,y).(y,x))(a,b)} requires the theorem \texttt{split} (which is in the
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1212
  default simpset) to rewrite to {\tt(b,a)}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1213
\end{warn}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1214
In addition to explicit $\lambda$-abstractions, patterns can be used in any
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1215
variable binding construct which is internally described by a
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1216
$\lambda$-abstraction.  Some important examples are
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1217
\begin{description}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1218
\item[Let:] \texttt{let {\it pattern} = $t$ in $u$}
10109
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  1219
\item[Quantifiers:] \texttt{ALL~{\it pattern}:$A$.~$P$}
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  1220
\item[Choice:] {\underscoreon \tt SOME~{\it pattern}.~$P$}
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1221
\item[Set operations:] \texttt{UN~{\it pattern}:$A$.~$B$}
10109
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  1222
\item[Sets:] \texttt{{\ttlbrace}{\it pattern}.~$P${\ttrbrace}}
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1223
\end{description}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1224
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1225
There is a simple tactic which supports reasoning about patterns:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1226
\begin{ttdescription}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1227
\item[\ttindexbold{split_all_tac} $i$] replaces in subgoal $i$ all
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1228
  {\tt!!}-quantified variables of product type by individual variables for
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1229
  each component.  A simple example:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1230
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1231
{\out 1. !!p. (\%(x,y,z). (x, y, z)) p = p}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1232
by(split_all_tac 1);
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1233
{\out 1. !!x xa ya. (\%(x,y,z). (x, y, z)) (x, xa, ya) = (x, xa, ya)}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1234
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1235
\end{ttdescription}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1236
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1237
Theory \texttt{Prod} also introduces the degenerate product type \texttt{unit}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1238
which contains only a single element named {\tt()} with the property
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1239
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1240
\tdx{unit_eq}       u = ()
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1241
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1242
\bigskip
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1243
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1244
Theory \thydx{Sum} (Fig.~\ref{hol-sum}) defines the sum type $\alpha+\beta$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1245
which associates to the right and has a lower priority than $*$: $\tau@1 +
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1246
\tau@2 + \tau@3*\tau@4$ means $\tau@1 + (\tau@2 + (\tau@3*\tau@4))$.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1247
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1248
The definition of products and sums in terms of existing types is not
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1249
shown.  The constructions are fairly standard and can be found in the
7325
01bb8abb5a91 Some changes in sections about Sum and Nat.
berghofe
parents: 7283
diff changeset
  1250
respective theory files. Although the sum and product types are
01bb8abb5a91 Some changes in sections about Sum and Nat.
berghofe
parents: 7283
diff changeset
  1251
constructed manually for foundational reasons, they are represented as
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
  1252
actual datatypes later (see {\S}\ref{subsec:datatype:rep_datatype}).
7325
01bb8abb5a91 Some changes in sections about Sum and Nat.
berghofe
parents: 7283
diff changeset
  1253
Therefore, the theory \texttt{Datatype} should be used instead of
01bb8abb5a91 Some changes in sections about Sum and Nat.
berghofe
parents: 7283
diff changeset
  1254
\texttt{Sum} or \texttt{Prod}.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1255
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1256
\begin{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1257
\begin{constants}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1258
  \it symbol    & \it meta-type &           & \it description \\ 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1259
  \cdx{Inl}     & $\alpha \To \alpha+\beta$    & & first injection\\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1260
  \cdx{Inr}     & $\beta \To \alpha+\beta$     & & second injection\\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1261
  \cdx{sum_case} & $[\alpha\To\gamma, \beta\To\gamma, \alpha+\beta] \To\gamma$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1262
        & & conditional
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1263
\end{constants}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1264
\begin{ttbox}\makeatletter
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1265
\tdx{Inl_not_Inr}    Inl a ~= Inr b
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1266
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1267
\tdx{inj_Inl}        inj Inl
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1268
\tdx{inj_Inr}        inj Inr
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1269
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1270
\tdx{sumE}           [| !!x. P(Inl x);  !!y. P(Inr y) |] ==> P s
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1271
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1272
\tdx{sum_case_Inl}   sum_case f g (Inl x) = f x
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1273
\tdx{sum_case_Inr}   sum_case f g (Inr x) = g x
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1274
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1275
\tdx{surjective_sum} sum_case (\%x. f(Inl x)) (\%y. f(Inr y)) s = f s
7325
01bb8abb5a91 Some changes in sections about Sum and Nat.
berghofe
parents: 7283
diff changeset
  1276
\tdx{sum.split_case} R(sum_case f g s) = ((! x. s = Inl(x) --> R(f(x))) &
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1277
                                     (! y. s = Inr(y) --> R(g(y))))
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1278
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1279
\caption{Type $\alpha+\beta$}\label{hol-sum}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1280
\end{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1281
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1282
\begin{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1283
\index{*"< symbol}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1284
\index{*"* symbol}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1285
\index{*div symbol}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1286
\index{*mod symbol}
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1287
\index{*dvd symbol}
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1288
\index{*"+ symbol}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1289
\index{*"- symbol}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1290
\begin{constants}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1291
  \it symbol    & \it meta-type & \it priority & \it description \\ 
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1292
  \cdx{0}       & $\alpha$  & & zero \\
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1293
  \cdx{Suc}     & $nat \To nat$ & & successor function\\
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1294
  \tt *    & $[\alpha,\alpha]\To \alpha$    &  Left 70 & multiplication \\
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1295
  \tt div  & $[\alpha,\alpha]\To \alpha$    &  Left 70 & division\\
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1296
  \tt mod  & $[\alpha,\alpha]\To \alpha$    &  Left 70 & modulus\\
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1297
  \tt dvd  & $[\alpha,\alpha]\To bool$     &  Left 70 & ``divides'' relation\\
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1298
  \tt +    & $[\alpha,\alpha]\To \alpha$    &  Left 65 & addition\\
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1299
  \tt -    & $[\alpha,\alpha]\To \alpha$    &  Left 65 & subtraction
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1300
\end{constants}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1301
\subcaption{Constants and infixes}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1302
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1303
\begin{ttbox}\makeatother
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1304
\tdx{nat_induct}     [| P 0; !!n. P n ==> P(Suc n) |]  ==> P n
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1305
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1306
\tdx{Suc_not_Zero}   Suc m ~= 0
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1307
\tdx{inj_Suc}        inj Suc
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1308
\tdx{n_not_Suc_n}    n~=Suc n
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1309
\subcaption{Basic properties}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1310
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1311
\caption{The type of natural numbers, \tydx{nat}} \label{hol-nat1}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1312
\end{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1313
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1314
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1315
\begin{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1316
\begin{ttbox}\makeatother
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1317
              0+n           = n
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1318
              (Suc m)+n     = Suc(m+n)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1319
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1320
              m-0           = m
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1321
              0-n           = n
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1322
              Suc(m)-Suc(n) = m-n
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1323
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1324
              0*n           = 0
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1325
              Suc(m)*n      = n + m*n
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1326
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1327
\tdx{mod_less}      m<n ==> m mod n = m
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1328
\tdx{mod_geq}       [| 0<n;  ~m<n |] ==> m mod n = (m-n) mod n
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1329
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1330
\tdx{div_less}      m<n ==> m div n = 0
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1331
\tdx{div_geq}       [| 0<n;  ~m<n |] ==> m div n = Suc((m-n) div n)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1332
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1333
\caption{Recursion equations for the arithmetic operators} \label{hol-nat2}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1334
\end{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1335
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1336
\subsection{The type of natural numbers, \textit{nat}}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1337
\index{nat@{\textit{nat}} type|(}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1338
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1339
The theory \thydx{NatDef} defines the natural numbers in a roundabout but
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1340
traditional way.  The axiom of infinity postulates a type~\tydx{ind} of
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1341
individuals, which is non-empty and closed under an injective operation.  The
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1342
natural numbers are inductively generated by choosing an arbitrary individual
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1343
for~0 and using the injective operation to take successors.  This is a least
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1344
fixedpoint construction.  For details see the file \texttt{NatDef.thy}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1345
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1346
Type~\tydx{nat} is an instance of class~\cldx{ord}, which makes the overloaded
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1347
functions of this class (especially \cdx{<} and \cdx{<=}, but also \cdx{min},
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1348
\cdx{max} and \cdx{LEAST}) available on \tydx{nat}.  Theory \thydx{Nat} builds
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1349
on \texttt{NatDef} and shows that {\tt<=} is a linear order, so \tydx{nat} is
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1350
also an instance of class \cldx{linorder}.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1351
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1352
Theory \thydx{Arith} develops arithmetic on the natural numbers.  It defines
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1353
addition, multiplication and subtraction.  Theory \thydx{Divides} defines
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1354
division, remainder and the ``divides'' relation.  The numerous theorems
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1355
proved include commutative, associative, distributive, identity and
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1356
cancellation laws.  See Figs.\ts\ref{hol-nat1} and~\ref{hol-nat2}.  The
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1357
recursion equations for the operators \texttt{+}, \texttt{-} and \texttt{*} on
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1358
\texttt{nat} are part of the default simpset.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1359
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1360
Functions on \tydx{nat} can be defined by primitive or well-founded recursion;
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
  1361
see {\S}\ref{sec:HOL:recursive}.  A simple example is addition.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1362
Here, \texttt{op +} is the name of the infix operator~\texttt{+}, following
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1363
the standard convention.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1364
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1365
\sdx{primrec}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1366
      "0 + n = n"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1367
  "Suc m + n = Suc (m + n)"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1368
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1369
There is also a \sdx{case}-construct
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1370
of the form
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1371
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1372
case \(e\) of 0 => \(a\) | Suc \(m\) => \(b\)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1373
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1374
Note that Isabelle insists on precisely this format; you may not even change
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1375
the order of the two cases.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1376
Both \texttt{primrec} and \texttt{case} are realized by a recursion operator
7325
01bb8abb5a91 Some changes in sections about Sum and Nat.
berghofe
parents: 7283
diff changeset
  1377
\cdx{nat_rec}, which is available because \textit{nat} is represented as
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
  1378
a datatype (see {\S}\ref{subsec:datatype:rep_datatype}).
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1379
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1380
%The predecessor relation, \cdx{pred_nat}, is shown to be well-founded.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1381
%Recursion along this relation resembles primitive recursion, but is
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1382
%stronger because we are in higher-order logic; using primitive recursion to
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1383
%define a higher-order function, we can easily Ackermann's function, which
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1384
%is not primitive recursive \cite[page~104]{thompson91}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1385
%The transitive closure of \cdx{pred_nat} is~$<$.  Many functions on the
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1386
%natural numbers are most easily expressed using recursion along~$<$.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1387
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1388
Tactic {\tt\ttindex{induct_tac} "$n$" $i$} performs induction on variable~$n$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1389
in subgoal~$i$ using theorem \texttt{nat_induct}.  There is also the derived
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1390
theorem \tdx{less_induct}:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1391
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1392
[| !!n. [| ! m. m<n --> P m |] ==> P n |]  ==>  P n
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1393
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1394
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1395
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1396
\subsection{Numerical types and numerical reasoning}
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1397
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  1398
The integers (type \tdx{int}) are also available in HOL, and the reals (type
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1399
\tdx{real}) are available in the logic image \texttt{HOL-Real}.  They support
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1400
the expected operations of addition (\texttt{+}), subtraction (\texttt{-}) and
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1401
multiplication (\texttt{*}), and much else.  Type \tdx{int} provides the
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1402
\texttt{div} and \texttt{mod} operators, while type \tdx{real} provides real
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1403
division and other operations.  Both types belong to class \cldx{linorder}, so
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1404
they inherit the relational operators and all the usual properties of linear
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1405
orderings.  For full details, please survey the theories in subdirectories
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1406
\texttt{Integ} and \texttt{Real}.
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1407
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1408
All three numeric types admit numerals of the form \texttt{\#$sd\ldots d$},
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1409
where $s$ is an optional minus sign and $d\ldots d$ is a string of digits.
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1410
Numerals are represented internally by a datatype for binary notation, which
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1411
allows numerical calculations to be performed by rewriting.  For example, the
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1412
integer division of \texttt{\#54342339} by \texttt{\#3452} takes about five
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1413
seconds.  By default, the simplifier cancels like terms on the opposite sites
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1414
of relational operators (reducing \texttt{z+x<x+y} to \texttt{z<y}, for
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1415
instance.  The simplifier also collects like terms, replacing
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1416
\texttt{x+y+x*\#3} by \texttt{\#4*x+y}.
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1417
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1418
Sometimes numerals are not wanted, because for example \texttt{n+\#3} does not
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1419
match a pattern of the form \texttt{Suc $k$}.  You can re-arrange the form of
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1420
an arithmetic expression by proving (via \texttt{subgoal_tac}) a lemma such
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1421
as \texttt{n+\#3 = Suc (Suc (Suc n))}.  As an alternative, you can disable the
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1422
fancier simplifications by using a basic simpset such as \texttt{HOL_ss}
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1423
rather than the default one, \texttt{simpset()}.
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1424
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1425
Reasoning about arithmetic inequalities can be tedious.  Fortunately HOL
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1426
provides a decision procedure for quantifier-free linear arithmetic (that is,
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1427
addition and subtraction). The simplifier invokes a weak version of this
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1428
decision procedure automatically. If this is not sufficent, you can invoke the
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1429
full procedure \ttindex{arith_tac} explicitly.  It copes with arbitrary
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1430
formulae involving {\tt=}, {\tt<}, {\tt<=}, {\tt+}, {\tt-}, {\tt Suc}, {\tt
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1431
  min}, {\tt max} and numerical constants; other subterms are treated as
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1432
atomic; subformulae not involving numerical types are ignored; quantified
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1433
subformulae are ignored unless they are positive universal or negative
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1434
existential. Note that the running time is exponential in the number of
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1435
occurrences of {\tt min}, {\tt max}, and {\tt-} because they require case
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1436
distinctions. Note also that \texttt{arith_tac} is not complete: if
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1437
divisibility plays a role, it may fail to prove a valid formula, for example
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1438
$m+m \neq n+n+1$. Fortunately such examples are rare in practice.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1439
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1440
If \texttt{arith_tac} fails you, try to find relevant arithmetic results in
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1441
the library.  The theory \texttt{NatDef} contains theorems about {\tt<} and
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1442
{\tt<=}, the theory \texttt{Arith} contains theorems about \texttt{+},
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1443
\texttt{-} and \texttt{*}, and theory \texttt{Divides} contains theorems about
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1444
\texttt{div} and \texttt{mod}.  Use \texttt{thms_containing} or the
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1445
\texttt{find}-functions to locate them (see the {\em Reference Manual\/}).
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1446
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1447
\index{nat@{\textit{nat}} type|)}
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1448
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1449
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1450
\begin{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1451
\index{#@{\tt[]} symbol}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1452
\index{#@{\tt\#} symbol}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1453
\index{"@@{\tt\at} symbol}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1454
\index{*"! symbol}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1455
\begin{constants}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1456
  \it symbol & \it meta-type & \it priority & \it description \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1457
  \tt[]    & $\alpha\,list$ & & empty list\\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1458
  \tt \#   & $[\alpha,\alpha\,list]\To \alpha\,list$ & Right 65 & 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1459
        list constructor \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1460
  \cdx{null}    & $\alpha\,list \To bool$ & & emptiness test\\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1461
  \cdx{hd}      & $\alpha\,list \To \alpha$ & & head \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1462
  \cdx{tl}      & $\alpha\,list \To \alpha\,list$ & & tail \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1463
  \cdx{last}    & $\alpha\,list \To \alpha$ & & last element \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1464
  \cdx{butlast} & $\alpha\,list \To \alpha\,list$ & & drop last element \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1465
  \tt\at  & $[\alpha\,list,\alpha\,list]\To \alpha\,list$ & Left 65 & append \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1466
  \cdx{map}     & $(\alpha\To\beta) \To (\alpha\,list \To \beta\,list)$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1467
        & & apply to all\\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1468
  \cdx{filter}  & $(\alpha \To bool) \To (\alpha\,list \To \alpha\,list)$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1469
        & & filter functional\\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1470
  \cdx{set}& $\alpha\,list \To \alpha\,set$ & & elements\\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1471
  \sdx{mem}  & $\alpha \To \alpha\,list \To bool$  &  Left 55   & membership\\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1472
  \cdx{foldl}   & $(\beta\To\alpha\To\beta) \To \beta \To \alpha\,list \To \beta$ &
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1473
  & iteration \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1474
  \cdx{concat}   & $(\alpha\,list)list\To \alpha\,list$ & & concatenation \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1475
  \cdx{rev}     & $\alpha\,list \To \alpha\,list$ & & reverse \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1476
  \cdx{length}  & $\alpha\,list \To nat$ & & length \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1477
  \tt! & $\alpha\,list \To nat \To \alpha$ & Left 100 & indexing \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1478
  \cdx{take}, \cdx{drop} & $nat \To \alpha\,list \To \alpha\,list$ &&
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1479
    take/drop a prefix \\
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1480
  \cdx{takeWhile},\\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1481
  \cdx{dropWhile} &
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1482
    $(\alpha \To bool) \To \alpha\,list \To \alpha\,list$ &&
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1483
    take/drop a prefix
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1484
\end{constants}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1485
\subcaption{Constants and infixes}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1486
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1487
\begin{center} \tt\frenchspacing
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1488
\begin{tabular}{rrr} 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1489
  \it external        & \it internal  & \it description \\{}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1490
  [$x@1$, $\dots$, $x@n$]  &  $x@1$ \# $\cdots$ \# $x@n$ \# [] &
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1491
        \rm finite list \\{}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1492
  [$x$:$l$. $P$]  & filter ($\lambda x{.}P$) $l$ & 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1493
        \rm list comprehension
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1494
\end{tabular}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1495
\end{center}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1496
\subcaption{Translations}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1497
\caption{The theory \thydx{List}} \label{hol-list}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1498
\end{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1499
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1500
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1501
\begin{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1502
\begin{ttbox}\makeatother
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1503
null [] = True
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1504
null (x#xs) = False
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1505
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1506
hd (x#xs) = x
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1507
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1508
tl (x#xs) = xs
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1509
tl [] = []
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1510
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1511
[] @ ys = ys
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1512
(x#xs) @ ys = x # xs @ ys
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1513
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1514
set [] = \ttlbrace\ttrbrace
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1515
set (x#xs) = insert x (set xs)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1516
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1517
x mem [] = False
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1518
x mem (y#ys) = (if y=x then True else x mem ys)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1519
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1520
concat([]) = []
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1521
concat(x#xs) = x @ concat(xs)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1522
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1523
rev([]) = []
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1524
rev(x#xs) = rev(xs) @ [x]
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1525
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1526
length([]) = 0
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1527
length(x#xs) = Suc(length(xs))
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1528
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1529
xs!0 = hd xs
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1530
xs!(Suc n) = (tl xs)!n
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1531
\end{ttbox}
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1532
\caption{Simple list processing functions}
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1533
\label{fig:HOL:list-simps}
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1534
\end{figure}
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1535
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1536
\begin{figure}
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1537
\begin{ttbox}\makeatother
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1538
map f [] = []
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1539
map f (x#xs) = f x # map f xs
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1540
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1541
filter P [] = []
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1542
filter P (x#xs) = (if P x then x#filter P xs else filter P xs)
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1543
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1544
foldl f a [] = a
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1545
foldl f a (x#xs) = foldl f (f a x) xs
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1546
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1547
take n [] = []
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1548
take n (x#xs) = (case n of 0 => [] | Suc(m) => x # take m xs)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1549
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1550
drop n [] = []
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1551
drop n (x#xs) = (case n of 0 => x#xs | Suc(m) => drop m xs)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1552
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1553
takeWhile P [] = []
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1554
takeWhile P (x#xs) = (if P x then x#takeWhile P xs else [])
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1555
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1556
dropWhile P [] = []
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1557
dropWhile P (x#xs) = (if P x then dropWhile P xs else xs)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1558
\end{ttbox}
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1559
\caption{Further list processing functions}
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1560
\label{fig:HOL:list-simps2}
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1561
\end{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1562
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1563
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1564
\subsection{The type constructor for lists, \textit{list}}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1565
\label{subsec:list}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1566
\index{list@{\textit{list}} type|(}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1567
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1568
Figure~\ref{hol-list} presents the theory \thydx{List}: the basic list
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1569
operations with their types and syntax.  Type $\alpha \; list$ is
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1570
defined as a \texttt{datatype} with the constructors {\tt[]} and {\tt\#}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1571
As a result the generic structural induction and case analysis tactics
8424
a1a41257f45f exhaust -> cases
nipkow
parents: 7846
diff changeset
  1572
\texttt{induct\_tac} and \texttt{cases\_tac} also become available for
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1573
lists.  A \sdx{case} construct of the form
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1574
\begin{center}\tt
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1575
case $e$ of [] => $a$  |  \(x\)\#\(xs\) => b
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1576
\end{center}
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
  1577
is defined by translation.  For details see~{\S}\ref{sec:HOL:datatype}. There
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1578
is also a case splitting rule \tdx{split_list_case}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1579
\[
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1580
\begin{array}{l}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1581
P(\mathtt{case}~e~\mathtt{of}~\texttt{[] =>}~a ~\texttt{|}~
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1582
               x\texttt{\#}xs~\texttt{=>}~f~x~xs) ~= \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1583
((e = \texttt{[]} \to P(a)) \land
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1584
 (\forall x~ xs. e = x\texttt{\#}xs \to P(f~x~xs)))
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1585
\end{array}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1586
\]
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1587
which can be fed to \ttindex{addsplits} just like
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
  1588
\texttt{split_if} (see~{\S}\ref{subsec:HOL:case:splitting}).
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1589
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1590
\texttt{List} provides a basic library of list processing functions defined by
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
  1591
primitive recursion (see~{\S}\ref{sec:HOL:primrec}).  The recursion equations
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1592
are shown in Figs.\ts\ref{fig:HOL:list-simps} and~\ref{fig:HOL:list-simps2}.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1593
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1594
\index{list@{\textit{list}} type|)}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1595
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1596
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1597
\subsection{Introducing new types} \label{sec:typedef}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1598
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  1599
The HOL-methodology dictates that all extensions to a theory should be
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  1600
\textbf{definitional}.  The type definition mechanism that meets this
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  1601
criterion is \ttindex{typedef}.  Note that \emph{type synonyms}, which are
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  1602
inherited from Pure and described elsewhere, are just syntactic abbreviations
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  1603
that have no logical meaning.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1604
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1605
\begin{warn}
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  1606
  Types in HOL must be non-empty; otherwise the quantifier rules would be
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
  1607
  unsound, because $\exists x. x=x$ is a theorem \cite[{\S}7]{paulson-COLOG}.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1608
\end{warn}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1609
A \bfindex{type definition} identifies the new type with a subset of
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1610
an existing type.  More precisely, the new type is defined by
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1611
exhibiting an existing type~$\tau$, a set~$A::\tau\,set$, and a
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1612
theorem of the form $x:A$.  Thus~$A$ is a non-empty subset of~$\tau$,
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1613
and the new type denotes this subset.  New functions are defined that
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1614
establish an isomorphism between the new type and the subset.  If
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1615
type~$\tau$ involves type variables $\alpha@1$, \ldots, $\alpha@n$,
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1616
then the type definition creates a type constructor
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1617
$(\alpha@1,\ldots,\alpha@n)ty$ rather than a particular type.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1618
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1619
\begin{figure}[htbp]
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1620
\begin{rail}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1621
typedef  : 'typedef' ( () | '(' name ')') type '=' set witness;
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1622
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1623
type    : typevarlist name ( () | '(' infix ')' );
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1624
set     : string;
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1625
witness : () | '(' id ')';
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1626
\end{rail}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1627
\caption{Syntax of type definitions}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1628
\label{fig:HOL:typedef}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1629
\end{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1630
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1631
The syntax for type definitions is shown in Fig.~\ref{fig:HOL:typedef}.  For
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1632
the definition of `typevarlist' and `infix' see
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1633
\iflabelundefined{chap:classical}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1634
{the appendix of the {\em Reference Manual\/}}%
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1635
{Appendix~\ref{app:TheorySyntax}}.  The remaining nonterminals have the
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1636
following meaning:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1637
\begin{description}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1638
\item[\it type:] the new type constructor $(\alpha@1,\dots,\alpha@n)ty$ with
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1639
  optional infix annotation.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1640
\item[\it name:] an alphanumeric name $T$ for the type constructor
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1641
  $ty$, in case $ty$ is a symbolic name.  Defaults to $ty$.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1642
\item[\it set:] the representing subset $A$.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1643
\item[\it witness:] name of a theorem of the form $a:A$ proving
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1644
  non-emptiness.  It can be omitted in case Isabelle manages to prove
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1645
  non-emptiness automatically.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1646
\end{description}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1647
If all context conditions are met (no duplicate type variables in
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1648
`typevarlist', no extra type variables in `set', and no free term variables
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1649
in `set'), the following components are added to the theory:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1650
\begin{itemize}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1651
\item a type $ty :: (term,\dots,term)term$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1652
\item constants
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1653
\begin{eqnarray*}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1654
T &::& \tau\;set \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1655
Rep_T &::& (\alpha@1,\dots,\alpha@n)ty \To \tau \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1656
Abs_T &::& \tau \To (\alpha@1,\dots,\alpha@n)ty
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1657
\end{eqnarray*}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1658
\item a definition and three axioms
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1659
\[
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1660
\begin{array}{ll}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1661
T{\tt_def} & T \equiv A \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1662
{\tt Rep_}T & Rep_T\,x \in T \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1663
{\tt Rep_}T{\tt_inverse} & Abs_T\,(Rep_T\,x) = x \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1664
{\tt Abs_}T{\tt_inverse} & y \in T \Imp Rep_T\,(Abs_T\,y) = y
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1665
\end{array}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1666
\]
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1667
stating that $(\alpha@1,\dots,\alpha@n)ty$ is isomorphic to $A$ by $Rep_T$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1668
and its inverse $Abs_T$.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1669
\end{itemize}
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  1670
Below are two simple examples of HOL type definitions.  Non-emptiness is
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  1671
proved automatically here.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1672
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1673
typedef unit = "{\ttlbrace}True{\ttrbrace}"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1674
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1675
typedef (prod)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1676
  ('a, 'b) "*"    (infixr 20)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1677
      = "{\ttlbrace}f . EX (a::'a) (b::'b). f = (\%x y. x = a & y = b){\ttrbrace}"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1678
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1679
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1680
Type definitions permit the introduction of abstract data types in a safe
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1681
way, namely by providing models based on already existing types.  Given some
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1682
abstract axiomatic description $P$ of a type, this involves two steps:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1683
\begin{enumerate}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1684
\item Find an appropriate type $\tau$ and subset $A$ which has the desired
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1685
  properties $P$, and make a type definition based on this representation.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1686
\item Prove that $P$ holds for $ty$ by lifting $P$ from the representation.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1687
\end{enumerate}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1688
You can now forget about the representation and work solely in terms of the
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1689
abstract properties $P$.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1690
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1691
\begin{warn}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1692
If you introduce a new type (constructor) $ty$ axiomatically, i.e.\ by
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1693
declaring the type and its operations and by stating the desired axioms, you
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1694
should make sure the type has a non-empty model.  You must also have a clause
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1695
\par
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1696
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1697
arities \(ty\) :: (term,\thinspace\(\dots\),{\thinspace}term){\thinspace}term
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1698
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1699
in your theory file to tell Isabelle that $ty$ is in class \texttt{term}, the
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  1700
class of all HOL types.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1701
\end{warn}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1702
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1703
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1704
\section{Records}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1705
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1706
At a first approximation, records are just a minor generalisation of tuples,
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1707
where components may be addressed by labels instead of just position (think of
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1708
{\ML}, for example).  The version of records offered by Isabelle/HOL is
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1709
slightly more advanced, though, supporting \emph{extensible record schemes}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1710
This admits operations that are polymorphic with respect to record extension,
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1711
yielding ``object-oriented'' effects like (single) inheritance.  See also
6592
c120262044b6 Now uses manual.bib; some references updated
paulson
parents: 6588
diff changeset
  1712
\cite{NaraschewskiW-TPHOLs98} for more details on object-oriented
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1713
verification and record subtyping in HOL.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1714
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1715
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1716
\subsection{Basics}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1717
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1718
Isabelle/HOL supports fixed and schematic records both at the level of terms
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1719
and types.  The concrete syntax is as follows:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1720
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1721
\begin{center}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1722
\begin{tabular}{l|l|l}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1723
  & record terms & record types \\ \hline
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1724
  fixed & $\record{x = a\fs y = b}$ & $\record{x \ty A\fs y \ty B}$ \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1725
  schematic & $\record{x = a\fs y = b\fs \more = m}$ &
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1726
    $\record{x \ty A\fs y \ty B\fs \more \ty M}$ \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1727
\end{tabular}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1728
\end{center}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1729
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1730
\noindent The \textsc{ascii} representation of $\record{x = a}$ is \texttt{(| x = a |)}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1731
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1732
A fixed record $\record{x = a\fs y = b}$ has field $x$ of value $a$ and field
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1733
$y$ of value $b$.  The corresponding type is $\record{x \ty A\fs y \ty B}$,
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1734
assuming that $a \ty A$ and $b \ty B$.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1735
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1736
A record scheme like $\record{x = a\fs y = b\fs \more = m}$ contains fields
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1737
$x$ and $y$ as before, but also possibly further fields as indicated by the
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1738
``$\more$'' notation (which is actually part of the syntax).  The improper
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1739
field ``$\more$'' of a record scheme is called the \emph{more part}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1740
Logically it is just a free variable, which is occasionally referred to as
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1741
\emph{row variable} in the literature.  The more part of a record scheme may
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1742
be instantiated by zero or more further components.  For example, above scheme
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1743
might get instantiated to $\record{x = a\fs y = b\fs z = c\fs \more = m'}$,
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1744
where $m'$ refers to a different more part.  Fixed records are special
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1745
instances of record schemes, where ``$\more$'' is properly terminated by the
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1746
$() :: unit$ element.  Actually, $\record{x = a\fs y = b}$ is just an
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1747
abbreviation for $\record{x = a\fs y = b\fs \more = ()}$.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1748
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1749
\medskip
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1750
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1751
There are two key features that make extensible records in a simply typed
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1752
language like HOL feasible:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1753
\begin{enumerate}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1754
\item the more part is internalised, as a free term or type variable,
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1755
\item field names are externalised, they cannot be accessed within the logic
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1756
  as first-class values.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1757
\end{enumerate}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1758
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1759
\medskip
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1760
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1761
In Isabelle/HOL record types have to be defined explicitly, fixing their field
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1762
names and types, and their (optional) parent record (see
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
  1763
{\S}\ref{sec:HOL:record-def}).  Afterwards, records may be formed using above
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1764
syntax, while obeying the canonical order of fields as given by their
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1765
declaration.  The record package also provides several operations like
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
  1766
selectors and updates (see {\S}\ref{sec:HOL:record-ops}), together with
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
  1767
characteristic properties (see {\S}\ref{sec:HOL:record-thms}).
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1768
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1769
There is an example theory demonstrating most basic aspects of extensible
10052
5fa8d8d5c852 renamed HOL/ex/Points to HOL/ex/Records;
wenzelm
parents: 9969
diff changeset
  1770
records (see theory \texttt{HOL/ex/Records} in the Isabelle sources).
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1771
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1772
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1773
\subsection{Defining records}\label{sec:HOL:record-def}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1774
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1775
The theory syntax for record type definitions is shown in
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1776
Fig.~\ref{fig:HOL:record}.  For the definition of `typevarlist' and `type' see
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1777
\iflabelundefined{chap:classical}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1778
{the appendix of the {\em Reference Manual\/}}%
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1779
{Appendix~\ref{app:TheorySyntax}}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1780
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1781
\begin{figure}[htbp]
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1782
\begin{rail}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1783
record  : 'record' typevarlist name '=' parent (field +);
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1784
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1785
parent  : ( () | type '+');
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1786
field   : name '::' type;
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1787
\end{rail}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1788
\caption{Syntax of record type definitions}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1789
\label{fig:HOL:record}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1790
\end{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1791
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1792
A general \ttindex{record} specification is of the following form:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1793
\[
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1794
\mathtt{record}~(\alpha@1, \dots, \alpha@n) \, t ~=~
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1795
  (\tau@1, \dots, \tau@m) \, s ~+~ c@1 :: \sigma@1 ~ \dots ~ c@l :: \sigma@l
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1796
\]
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1797
where $\vec\alpha@n$ are distinct type variables, and $\vec\tau@m$,
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1798
$\vec\sigma@l$ are types containing at most variables from $\vec\alpha@n$.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1799
Type constructor $t$ has to be new, while $s$ has to specify an existing
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1800
record type.  Furthermore, the $\vec c@l$ have to be distinct field names.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1801
There has to be at least one field.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1802
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1803
In principle, field names may never be shared with other records.  This is no
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1804
actual restriction in practice, since $\vec c@l$ are internally declared
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1805
within a separate name space qualified by the name $t$ of the record.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1806
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1807
\medskip
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1808
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1809
Above definition introduces a new record type $(\vec\alpha@n) \, t$ by
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1810
extending an existing one $(\vec\tau@m) \, s$ by new fields $\vec c@l \ty
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1811
\vec\sigma@l$.  The parent record specification is optional, by omitting it
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1812
$t$ becomes a \emph{root record}.  The hierarchy of all records declared
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1813
within a theory forms a forest structure, i.e.\ a set of trees, where any of
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1814
these is rooted by some root record.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1815
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1816
For convenience, $(\vec\alpha@n) \, t$ is made a type abbreviation for the
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1817
fixed record type $\record{\vec c@l \ty \vec\sigma@l}$, and $(\vec\alpha@n,
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1818
\zeta) \, t_scheme$ is made an abbreviation for $\record{\vec c@l \ty
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1819
  \vec\sigma@l\fs \more \ty \zeta}$.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1820
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1821
\medskip
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1822
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1823
The following simple example defines a root record type $point$ with fields $x
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1824
\ty nat$ and $y \ty nat$, and record type $cpoint$ by extending $point$ with
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1825
an additional $colour$ component.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1826
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1827
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1828
  record point =
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1829
    x :: nat
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1830
    y :: nat
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1831
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1832
  record cpoint = point +
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1833
    colour :: string
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1834
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1835
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1836
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1837
\subsection{Record operations}\label{sec:HOL:record-ops}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1838
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1839
Any record definition of the form presented above produces certain standard
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1840
operations.  Selectors and updates are provided for any field, including the
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1841
improper one ``$more$''.  There are also cumulative record constructor
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1842
functions.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1843
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1844
To simplify the presentation below, we first assume that $(\vec\alpha@n) \, t$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1845
is a root record with fields $\vec c@l \ty \vec\sigma@l$.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1846
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1847
\medskip
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1848
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1849
\textbf{Selectors} and \textbf{updates} are available for any field (including
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1850
``$more$'') as follows:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1851
\begin{matharray}{lll}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1852
  c@i & \ty & \record{\vec c@l \ty \vec \sigma@l, \more \ty \zeta} \To \sigma@i \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1853
  c@i_update & \ty & \sigma@i \To \record{\vec c@l \ty \vec \sigma@l, \more \ty \zeta} \To
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1854
    \record{\vec c@l \ty \vec \sigma@l, \more \ty \zeta}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1855
\end{matharray}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1856
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1857
There is some special syntax for updates: $r \, \record{x \asn a}$ abbreviates
10109
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  1858
term $x_update \, a \, r$.  Repeated updates are supported as well: $r \,
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1859
\record{x \asn a} \, \record{y \asn b} \, \record{z \asn c}$ may be written as
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1860
$r \, \record{x \asn a\fs y \asn b\fs z \asn c}$.  Note that because of
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1861
postfix notation the order of fields shown here is reverse than in the actual
10109
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  1862
term.  This might lead to confusion in conjunction with special proof tools
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  1863
such as ordered rewriting.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1864
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1865
Since repeated updates are just function applications, fields may be freely
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1866
permuted in $\record{x \asn a\fs y \asn b\fs z \asn c}$, as far as the logic
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1867
is concerned.  Thus commutativity of updates can be proven within the logic
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1868
for any two fields, but not as a general theorem: fields are not first-class
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1869
values.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1870
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1871
\medskip
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1872
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1873
\textbf{Make} operations provide cumulative record constructor functions:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1874
\begin{matharray}{lll}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1875
  make & \ty & \vec\sigma@l \To \record{\vec c@l \ty \vec \sigma@l} \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1876
  make_scheme & \ty & \vec\sigma@l \To
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1877
    \zeta \To \record{\vec c@l \ty \vec \sigma@l, \more \ty \zeta} \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1878
\end{matharray}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1879
\noindent
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1880
These functions are curried.  The corresponding definitions in terms of actual
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1881
record terms are part of the standard simpset.  Thus $point\dtt make\,a\,b$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1882
rewrites to $\record{x = a\fs y = b}$.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1883
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1884
\medskip
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1885
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1886
Any of above selector, update and make operations are declared within a local
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1887
name space prefixed by the name $t$ of the record.  In case that different
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1888
records share base names of fields, one has to qualify names explicitly (e.g.\ 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1889
$t\dtt c@i_update$).  This is recommended especially for operations like
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1890
$make$ or $update_more$ that always have the same base name.  Just use $t\dtt
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1891
make$ etc.\ to avoid confusion.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1892
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1893
\bigskip
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1894
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1895
We reconsider the case of non-root records, which are derived of some parent
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1896
record.  In general, the latter may depend on another parent as well,
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1897
resulting in a list of \emph{ancestor records}.  Appending the lists of fields
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1898
of all ancestors results in a certain field prefix.  The record package
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1899
automatically takes care of this by lifting operations over this context of
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1900
ancestor fields.  Assuming that $(\vec\alpha@n) \, t$ has ancestor fields
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1901
$\vec d@k \ty \vec\rho@k$, selectors will get the following types:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1902
\begin{matharray}{lll}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1903
  c@i & \ty & \record{\vec d@k \ty \vec\rho@k, \vec c@l \ty \vec \sigma@l, \more \ty \zeta}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1904
    \To \sigma@i
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1905
\end{matharray}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1906
\noindent
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1907
Update and make operations are analogous.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1908
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1909
10109
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  1910
\subsection{Record proof tools}\label{sec:HOL:record-thms}
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  1911
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  1912
The record package declares the following proof rules for any record type $t$.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1913
\begin{enumerate}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1914
  
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1915
\item Standard conversions (selectors or updates applied to record constructor
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1916
  terms, make function definitions) are part of the standard simpset (via
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1917
  \texttt{addsimps}).
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1918
  
7328
4265615b4206 record_simproc;
wenzelm
parents: 7325
diff changeset
  1919
\item Selectors applied to updated records are automatically reduced by
4265615b4206 record_simproc;
wenzelm
parents: 7325
diff changeset
  1920
  simplification procedure \ttindex{record_simproc}, which is part of the
4265615b4206 record_simproc;
wenzelm
parents: 7325
diff changeset
  1921
  default simpset.
4265615b4206 record_simproc;
wenzelm
parents: 7325
diff changeset
  1922
  
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1923
\item Inject equations of a form analogous to $((x, y) = (x', y')) \equiv x=x'
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1924
  \conj y=y'$ are made part of the standard simpset and claset (via
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1925
  \texttt{addIffs}).
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1926
  
10109
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  1927
\item The introduction rule for record equality analogous to $x~r = x~r' \Imp
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  1928
  y~r = y~r' \Imp \dots \Imp r = r'$ is added to the simpset and to the claset
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  1929
  (as an ``extra introduction'').
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  1930
  
7328
4265615b4206 record_simproc;
wenzelm
parents: 7325
diff changeset
  1931
\item A tactic for record field splitting (\ttindex{record_split_tac}) may be
4265615b4206 record_simproc;
wenzelm
parents: 7325
diff changeset
  1932
  made part of the claset (via \texttt{addSWrapper}).  This tactic is based on
4265615b4206 record_simproc;
wenzelm
parents: 7325
diff changeset
  1933
  rules analogous to $(\All x PROP~P~x) \equiv (\All{a~b} PROP~P(a, b))$ for
4265615b4206 record_simproc;
wenzelm
parents: 7325
diff changeset
  1934
  any field.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1935
\end{enumerate}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1936
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1937
The first two kinds of rules are stored within the theory as $t\dtt simps$ and
10109
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  1938
$t\dtt iffs$, respectively; record equality introduction is available as
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  1939
$t\dtt equality$.  In some situations it might be appropriate to expand the
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  1940
definitions of updates: $t\dtt update_defs$.  Note that these names are
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  1941
\emph{not} bound at the {\ML} level.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1942
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1943
\medskip
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1944
10109
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  1945
Most of the time, plain Simplification should be sufficient to solve goals
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  1946
involving records.  Combinations of the Simplifier and Classical Reasoner
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  1947
(\texttt{Auto_tac} or \texttt{Force_tac}) are very useful, too.  The example
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  1948
theory \texttt{HOL/ex/Records} demonstrates typical proofs concerning records.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1949
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1950
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1951
\section{Datatype definitions}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1952
\label{sec:HOL:datatype}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1953
\index{*datatype|(}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1954
6626
wenzelm
parents: 6620
diff changeset
  1955
Inductive datatypes, similar to those of \ML, frequently appear in
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1956
applications of Isabelle/HOL.  In principle, such types could be defined by
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
  1957
hand via \texttt{typedef} (see {\S}\ref{sec:typedef}), but this would be far too
6626
wenzelm
parents: 6620
diff changeset
  1958
tedious.  The \ttindex{datatype} definition package of Isabelle/HOL (cf.\ 
wenzelm
parents: 6620
diff changeset
  1959
\cite{Berghofer-Wenzel:1999:TPHOL}) automates such chores.  It generates an
wenzelm
parents: 6620
diff changeset
  1960
appropriate \texttt{typedef} based on a least fixed-point construction, and
wenzelm
parents: 6620
diff changeset
  1961
proves freeness theorems and induction rules, as well as theorems for
wenzelm
parents: 6620
diff changeset
  1962
recursion and case combinators.  The user just has to give a simple
wenzelm
parents: 6620
diff changeset
  1963
specification of new inductive types using a notation similar to {\ML} or
wenzelm
parents: 6620
diff changeset
  1964
Haskell.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1965
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1966
The current datatype package can handle both mutual and indirect recursion.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1967
It also offers to represent existing types as datatypes giving the advantage
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1968
of a more uniform view on standard theories.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1969
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1970
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1971
\subsection{Basics}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1972
\label{subsec:datatype:basics}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1973
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1974
A general \texttt{datatype} definition is of the following form:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1975
\[
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1976
\begin{array}{llcl}
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1977
\mathtt{datatype} & (\vec{\alpha})t@1 & = &
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1978
  C^1@1~\tau^1@{1,1}~\ldots~\tau^1@{1,m^1@1} ~\mid~ \ldots ~\mid~
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1979
    C^1@{k@1}~\tau^1@{k@1,1}~\ldots~\tau^1@{k@1,m^1@{k@1}} \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1980
 & & \vdots \\
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1981
\mathtt{and} & (\vec{\alpha})t@n & = &
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1982
  C^n@1~\tau^n@{1,1}~\ldots~\tau^n@{1,m^n@1} ~\mid~ \ldots ~\mid~
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1983
    C^n@{k@n}~\tau^n@{k@n,1}~\ldots~\tau^n@{k@n,m^n@{k@n}}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1984
\end{array}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1985
\]
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1986
where $\vec{\alpha} = (\alpha@1,\ldots,\alpha@h)$ is a list of type variables,
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1987
$C^j@i$ are distinct constructor names and $\tau^j@{i,i'}$ are {\em
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1988
  admissible} types containing at most the type variables $\alpha@1, \ldots,
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1989
\alpha@h$. A type $\tau$ occurring in a \texttt{datatype} definition is {\em
9258
2121ff73a37d fixed typos reported by Jeremy Dawson
paulson
parents: 9212
diff changeset
  1990
  admissible} if and only if
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1991
\begin{itemize}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1992
\item $\tau$ is non-recursive, i.e.\ $\tau$ does not contain any of the
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1993
newly defined type constructors $t@1,\ldots,t@n$, or
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  1994
\item $\tau = (\vec{\alpha})t@{j'}$ where $1 \leq j' \leq n$, or
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1995
\item $\tau = (\tau'@1,\ldots,\tau'@{h'})t'$, where $t'$ is
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1996
the type constructor of an already existing datatype and $\tau'@1,\ldots,\tau'@{h'}$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  1997
are admissible types.
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
  1998
\item $\tau = \sigma \to \tau'$, where $\tau'$ is an admissible
7044
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  1999
type and $\sigma$ is non-recursive (i.e. the occurrences of the newly defined
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2000
types are {\em strictly positive})
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2001
\end{itemize}
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  2002
If some $(\vec{\alpha})t@{j'}$ occurs in a type $\tau^j@{i,i'}$
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2003
of the form
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2004
\[
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  2005
(\ldots,\ldots ~ (\vec{\alpha})t@{j'} ~ \ldots,\ldots)t'
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2006
\]
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2007
this is called a {\em nested} (or \emph{indirect}) occurrence. A very simple
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2008
example of a datatype is the type \texttt{list}, which can be defined by
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2009
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2010
datatype 'a list = Nil
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2011
                 | Cons 'a ('a list)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2012
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2013
Arithmetic expressions \texttt{aexp} and boolean expressions \texttt{bexp} can be modelled
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2014
by the mutually recursive datatype definition
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2015
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2016
datatype 'a aexp = If_then_else ('a bexp) ('a aexp) ('a aexp)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2017
                 | Sum ('a aexp) ('a aexp)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2018
                 | Diff ('a aexp) ('a aexp)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2019
                 | Var 'a
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2020
                 | Num nat
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2021
and      'a bexp = Less ('a aexp) ('a aexp)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2022
                 | And ('a bexp) ('a bexp)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2023
                 | Or ('a bexp) ('a bexp)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2024
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2025
The datatype \texttt{term}, which is defined by
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2026
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2027
datatype ('a, 'b) term = Var 'a
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2028
                       | App 'b ((('a, 'b) term) list)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2029
\end{ttbox}
7044
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2030
is an example for a datatype with nested recursion. Using nested recursion
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2031
involving function spaces, we may also define infinitely branching datatypes, e.g.
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2032
\begin{ttbox}
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2033
datatype 'a tree = Atom 'a | Branch "nat => 'a tree"
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2034
\end{ttbox}
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2035
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2036
\medskip
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2037
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2038
Types in HOL must be non-empty. Each of the new datatypes
9258
2121ff73a37d fixed typos reported by Jeremy Dawson
paulson
parents: 9212
diff changeset
  2039
$(\vec{\alpha})t@j$ with $1 \leq j \leq n$ is non-empty if and only if it has a
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2040
constructor $C^j@i$ with the following property: for all argument types
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  2041
$\tau^j@{i,i'}$ of the form $(\vec{\alpha})t@{j'}$ the datatype
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  2042
$(\vec{\alpha})t@{j'}$ is non-empty.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2043
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2044
If there are no nested occurrences of the newly defined datatypes, obviously
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  2045
at least one of the newly defined datatypes $(\vec{\alpha})t@j$
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2046
must have a constructor $C^j@i$ without recursive arguments, a \emph{base
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2047
  case}, to ensure that the new types are non-empty. If there are nested
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2048
occurrences, a datatype can even be non-empty without having a base case
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2049
itself. Since \texttt{list} is a non-empty datatype, \texttt{datatype t = C (t
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2050
  list)} is non-empty as well.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2051
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2052
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2053
\subsubsection{Freeness of the constructors}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2054
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2055
The datatype constructors are automatically defined as functions of their
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2056
respective type:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2057
\[ C^j@i :: [\tau^j@{i,1},\dots,\tau^j@{i,m^j@i}] \To (\alpha@1,\dots,\alpha@h)t@j \]
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2058
These functions have certain {\em freeness} properties.  They construct
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2059
distinct values:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2060
\[
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2061
C^j@i~x@1~\dots~x@{m^j@i} \neq C^j@{i'}~y@1~\dots~y@{m^j@{i'}} \qquad
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2062
\mbox{for all}~ i \neq i'.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2063
\]
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2064
The constructor functions are injective:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2065
\[
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2066
(C^j@i~x@1~\dots~x@{m^j@i} = C^j@i~y@1~\dots~y@{m^j@i}) =
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2067
(x@1 = y@1 \land \dots \land x@{m^j@i} = y@{m^j@i})
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2068
\]
7044
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2069
Since the number of distinctness inequalities is quadratic in the number of
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2070
constructors, the datatype package avoids proving them separately if there are
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2071
too many constructors. Instead, specific inequalities are proved by a suitable
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2072
simplification procedure on demand.\footnote{This procedure, which is already part
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2073
of the default simpset, may be referred to by the ML identifier
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2074
\texttt{DatatypePackage.distinct_simproc}.}
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2075
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2076
\subsubsection{Structural induction}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2077
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2078
The datatype package also provides structural induction rules.  For
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2079
datatypes without nested recursion, this is of the following form:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2080
\[
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
  2081
\infer{P@1~x@1 \land \dots \land P@n~x@n}
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2082
  {\begin{array}{lcl}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2083
     \Forall x@1 \dots x@{m^1@1}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2084
       \List{P@{s^1@{1,1}}~x@{r^1@{1,1}}; \dots;
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2085
         P@{s^1@{1,l^1@1}}~x@{r^1@{1,l^1@1}}} & \Imp &
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2086
           P@1~\left(C^1@1~x@1~\dots~x@{m^1@1}\right) \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2087
     & \vdots \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2088
     \Forall x@1 \dots x@{m^1@{k@1}}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2089
       \List{P@{s^1@{k@1,1}}~x@{r^1@{k@1,1}}; \dots;
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2090
         P@{s^1@{k@1,l^1@{k@1}}}~x@{r^1@{k@1,l^1@{k@1}}}} & \Imp &
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2091
           P@1~\left(C^1@{k@1}~x@1~\ldots~x@{m^1@{k@1}}\right) \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2092
     & \vdots \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2093
     \Forall x@1 \dots x@{m^n@1}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2094
       \List{P@{s^n@{1,1}}~x@{r^n@{1,1}}; \dots;
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2095
         P@{s^n@{1,l^n@1}}~x@{r^n@{1,l^n@1}}} & \Imp &
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2096
           P@n~\left(C^n@1~x@1~\ldots~x@{m^n@1}\right) \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2097
     & \vdots \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2098
     \Forall x@1 \dots x@{m^n@{k@n}}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2099
       \List{P@{s^n@{k@n,1}}~x@{r^n@{k@n,1}}; \dots
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2100
         P@{s^n@{k@n,l^n@{k@n}}}~x@{r^n@{k@n,l^n@{k@n}}}} & \Imp &
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2101
           P@n~\left(C^n@{k@n}~x@1~\ldots~x@{m^n@{k@n}}\right)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2102
   \end{array}}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2103
\]
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2104
where
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2105
\[
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2106
\begin{array}{rcl}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2107
Rec^j@i & := &
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2108
   \left\{\left(r^j@{i,1},s^j@{i,1}\right),\ldots,
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2109
     \left(r^j@{i,l^j@i},s^j@{i,l^j@i}\right)\right\} = \\[2ex]
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2110
&& \left\{(i',i'')~\left|~
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
  2111
     1\leq i' \leq m^j@i \land 1 \leq i'' \leq n \land
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2112
       \tau^j@{i,i'} = (\alpha@1,\ldots,\alpha@h)t@{i''}\right.\right\}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2113
\end{array}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2114
\]
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2115
i.e.\ the properties $P@j$ can be assumed for all recursive arguments.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2116
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2117
For datatypes with nested recursion, such as the \texttt{term} example from
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2118
above, things are a bit more complicated.  Conceptually, Isabelle/HOL unfolds
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2119
a definition like
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2120
\begin{ttbox}
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  2121
datatype ('a,'b) term = Var 'a
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  2122
                      | App 'b ((('a, 'b) term) list)
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2123
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2124
to an equivalent definition without nesting:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2125
\begin{ttbox}
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  2126
datatype ('a,'b) term      = Var
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  2127
                           | App 'b (('a, 'b) term_list)
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  2128
and      ('a,'b) term_list = Nil'
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  2129
                           | Cons' (('a,'b) term) (('a,'b) term_list)
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2130
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2131
Note however, that the type \texttt{('a,'b) term_list} and the constructors {\tt
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2132
  Nil'} and \texttt{Cons'} are not really introduced.  One can directly work with
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2133
the original (isomorphic) type \texttt{(('a, 'b) term) list} and its existing
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2134
constructors \texttt{Nil} and \texttt{Cons}. Thus, the structural induction rule for
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2135
\texttt{term} gets the form
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2136
\[
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
  2137
\infer{P@1~x@1 \land P@2~x@2}
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2138
  {\begin{array}{l}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2139
     \Forall x.~P@1~(\mathtt{Var}~x) \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2140
     \Forall x@1~x@2.~P@2~x@2 \Imp P@1~(\mathtt{App}~x@1~x@2) \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2141
     P@2~\mathtt{Nil} \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2142
     \Forall x@1~x@2. \List{P@1~x@1; P@2~x@2} \Imp P@2~(\mathtt{Cons}~x@1~x@2)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2143
   \end{array}}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2144
\]
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2145
Note that there are two predicates $P@1$ and $P@2$, one for the type \texttt{('a,'b) term}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2146
and one for the type \texttt{(('a, 'b) term) list}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2147
7044
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2148
For a datatype with function types such as \texttt{'a tree}, the induction rule
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2149
is of the form
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2150
\[
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2151
\infer{P~t}
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2152
  {\Forall a.~P~(\mathtt{Atom}~a) &
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2153
   \Forall ts.~(\forall x.~P~(ts~x)) \Imp P~(\mathtt{Branch}~ts)}
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2154
\]
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2155
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2156
\medskip In principle, inductive types are already fully determined by
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2157
freeness and structural induction.  For convenience in applications,
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2158
the following derived constructions are automatically provided for any
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2159
datatype.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2160
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2161
\subsubsection{The \sdx{case} construct}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2162
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2163
The type comes with an \ML-like \texttt{case}-construct:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2164
\[
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2165
\begin{array}{rrcl}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2166
\mbox{\tt case}~e~\mbox{\tt of} & C^j@1~x@{1,1}~\dots~x@{1,m^j@1} & \To & e@1 \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2167
                           \vdots \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2168
                           \mid & C^j@{k@j}~x@{k@j,1}~\dots~x@{k@j,m^j@{k@j}} & \To & e@{k@j}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2169
\end{array}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2170
\]
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2171
where the $x@{i,j}$ are either identifiers or nested tuple patterns as in
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
  2172
{\S}\ref{subsec:prod-sum}.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2173
\begin{warn}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2174
  All constructors must be present, their order is fixed, and nested patterns
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2175
  are not supported (with the exception of tuples).  Violating this
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2176
  restriction results in strange error messages.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2177
\end{warn}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2178
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2179
To perform case distinction on a goal containing a \texttt{case}-construct,
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2180
the theorem $t@j.$\texttt{split} is provided:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2181
\[
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2182
\begin{array}{@{}rcl@{}}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2183
P(t@j_\mathtt{case}~f@1~\dots~f@{k@j}~e) &\!\!\!=&
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2184
\!\!\! ((\forall x@1 \dots x@{m^j@1}. e = C^j@1~x@1\dots x@{m^j@1} \to
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2185
                             P(f@1~x@1\dots x@{m^j@1})) \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2186
&&\!\!\! ~\land~ \dots ~\land \\
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2187
&&~\!\!\! (\forall x@1 \dots x@{m^j@{k@j}}. e = C^j@{k@j}~x@1\dots x@{m^j@{k@j}} \to
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2188
                             P(f@{k@j}~x@1\dots x@{m^j@{k@j}})))
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2189
\end{array}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2190
\]
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2191
where $t@j$\texttt{_case} is the internal name of the \texttt{case}-construct.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2192
This theorem can be added to a simpset via \ttindex{addsplits}
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
  2193
(see~{\S}\ref{subsec:HOL:case:splitting}).
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2194
10109
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  2195
Case splitting on assumption works as well, by using the rule
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  2196
$t@j.$\texttt{split_asm} in the same manner.  Both rules are available under
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  2197
$t@j.$\texttt{splits} (this name is \emph{not} bound in ML, though).
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  2198
8604
c99e0024050c *** empty log message ***
nipkow
parents: 8443
diff changeset
  2199
\begin{warn}\index{simplification!of \texttt{case}}%
c99e0024050c *** empty log message ***
nipkow
parents: 8443
diff changeset
  2200
  By default only the selector expression ($e$ above) in a
c99e0024050c *** empty log message ***
nipkow
parents: 8443
diff changeset
  2201
  \texttt{case}-construct is simplified, in analogy with \texttt{if} (see
c99e0024050c *** empty log message ***
nipkow
parents: 8443
diff changeset
  2202
  page~\pageref{if-simp}). Only if that reduces to a constructor is one of
c99e0024050c *** empty log message ***
nipkow
parents: 8443
diff changeset
  2203
  the arms of the \texttt{case}-construct exposed and simplified. To ensure
c99e0024050c *** empty log message ***
nipkow
parents: 8443
diff changeset
  2204
  full simplification of all parts of a \texttt{case}-construct for datatype
c99e0024050c *** empty log message ***
nipkow
parents: 8443
diff changeset
  2205
  $t$, remove $t$\texttt{.}\ttindexbold{case_weak_cong} from the simpset, for
c99e0024050c *** empty log message ***
nipkow
parents: 8443
diff changeset
  2206
  example by \texttt{delcongs [thm "$t$.weak_case_cong"]}.
c99e0024050c *** empty log message ***
nipkow
parents: 8443
diff changeset
  2207
\end{warn}
c99e0024050c *** empty log message ***
nipkow
parents: 8443
diff changeset
  2208
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2209
\subsubsection{The function \cdx{size}}\label{sec:HOL:size}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2210
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2211
Theory \texttt{Arith} declares a generic function \texttt{size} of type
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2212
$\alpha\To nat$.  Each datatype defines a particular instance of \texttt{size}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2213
by overloading according to the following scheme:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2214
%%% FIXME: This formula is too big and is completely unreadable
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2215
\[
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2216
size(C^j@i~x@1~\dots~x@{m^j@i}) = \!
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2217
\left\{
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2218
\begin{array}{ll}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2219
0 & \!\mbox{if $Rec^j@i = \emptyset$} \\
7044
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2220
1+\sum\limits@{h=1}^{l^j@i}size~x@{r^j@{i,h}} &
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2221
 \!\mbox{if $Rec^j@i = \left\{\left(r^j@{i,1},s^j@{i,1}\right),\ldots,
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2222
  \left(r^j@{i,l^j@i},s^j@{i,l^j@i}\right)\right\}$}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2223
\end{array}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2224
\right.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2225
\]
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2226
where $Rec^j@i$ is defined above.  Viewing datatypes as generalised trees, the
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2227
size of a leaf is 0 and the size of a node is the sum of the sizes of its
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2228
subtrees ${}+1$.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2229
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2230
\subsection{Defining datatypes}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2231
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2232
The theory syntax for datatype definitions is shown in
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2233
Fig.~\ref{datatype-grammar}.  In order to be well-formed, a datatype
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2234
definition has to obey the rules stated in the previous section.  As a result
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2235
the theory is extended with the new types, the constructors, and the theorems
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2236
listed in the previous section.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2237
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2238
\begin{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2239
\begin{rail}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2240
datatype : 'datatype' typedecls;
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2241
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2242
typedecls: ( newtype '=' (cons + '|') ) + 'and'
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2243
         ;
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2244
newtype  : typevarlist id ( () | '(' infix ')' )
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2245
         ;
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2246
cons     : name (argtype *) ( () | ( '(' mixfix ')' ) )
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2247
         ;
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2248
argtype  : id | tid | ('(' typevarlist id ')')
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2249
         ;
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2250
\end{rail}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2251
\caption{Syntax of datatype declarations}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2252
\label{datatype-grammar}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2253
\end{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2254
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2255
Most of the theorems about datatypes become part of the default simpset and
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2256
you never need to see them again because the simplifier applies them
8424
a1a41257f45f exhaust -> cases
nipkow
parents: 7846
diff changeset
  2257
automatically.  Only induction or case distinction are usually invoked by hand.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2258
\begin{ttdescription}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2259
\item[\ttindexbold{induct_tac} {\tt"}$x${\tt"} $i$]
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2260
 applies structural induction on variable $x$ to subgoal $i$, provided the
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2261
 type of $x$ is a datatype.
7846
adf6b1112bc1 Eliminated mutual_induct_tac.
berghofe
parents: 7830
diff changeset
  2262
\item[\texttt{induct_tac}
adf6b1112bc1 Eliminated mutual_induct_tac.
berghofe
parents: 7830
diff changeset
  2263
  {\tt"}$x@1$ $\ldots$ $x@n${\tt"} $i$] applies simultaneous
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2264
  structural induction on the variables $x@1,\ldots,x@n$ to subgoal $i$.  This
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2265
  is the canonical way to prove properties of mutually recursive datatypes
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2266
  such as \texttt{aexp} and \texttt{bexp}, or datatypes with nested recursion such as
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2267
  \texttt{term}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2268
\end{ttdescription}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2269
In some cases, induction is overkill and a case distinction over all
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2270
constructors of the datatype suffices.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2271
\begin{ttdescription}
8443
0ed4b608ba4b renamed cases_tac to case_tac;
wenzelm
parents: 8424
diff changeset
  2272
\item[\ttindexbold{case_tac} {\tt"}$u${\tt"} $i$]
8424
a1a41257f45f exhaust -> cases
nipkow
parents: 7846
diff changeset
  2273
 performs a case analysis for the term $u$ whose type  must be a datatype.
a1a41257f45f exhaust -> cases
nipkow
parents: 7846
diff changeset
  2274
 If the datatype has $k@j$ constructors  $C^j@1$, \dots $C^j@{k@j}$, subgoal
a1a41257f45f exhaust -> cases
nipkow
parents: 7846
diff changeset
  2275
 $i$ is replaced by $k@j$ new subgoals which  contain the additional
a1a41257f45f exhaust -> cases
nipkow
parents: 7846
diff changeset
  2276
 assumption $u = C^j@{i'}~x@1~\dots~x@{m^j@{i'}}$ for  $i'=1$, $\dots$,~$k@j$.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2277
\end{ttdescription}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2278
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2279
Note that induction is only allowed on free variables that should not occur
8424
a1a41257f45f exhaust -> cases
nipkow
parents: 7846
diff changeset
  2280
among the premises of the subgoal. Case distinction applies to arbitrary terms.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2281
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2282
\bigskip
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2283
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2284
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2285
For the technically minded, we exhibit some more details.  Processing the
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2286
theory file produces an \ML\ structure which, in addition to the usual
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2287
components, contains a structure named $t$ for each datatype $t$ defined in
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2288
the file.  Each structure $t$ contains the following elements:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2289
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2290
val distinct : thm list
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2291
val inject : thm list
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2292
val induct : thm
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2293
val exhaust : thm
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2294
val cases : thm list
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2295
val split : thm
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2296
val split_asm : thm
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2297
val recs : thm list
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2298
val size : thm list
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2299
val simps : thm list
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2300
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2301
\texttt{distinct}, \texttt{inject}, \texttt{induct}, \texttt{size}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2302
and \texttt{split} contain the theorems
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2303
described above.  For user convenience, \texttt{distinct} contains
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2304
inequalities in both directions.  The reduction rules of the {\tt
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2305
  case}-construct are in \texttt{cases}.  All theorems from {\tt
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2306
  distinct}, \texttt{inject} and \texttt{cases} are combined in \texttt{simps}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2307
In case of mutually recursive datatypes, \texttt{recs}, \texttt{size}, \texttt{induct}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2308
and \texttt{simps} are contained in a separate structure named $t@1_\ldots_t@n$.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2309
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2310
7325
01bb8abb5a91 Some changes in sections about Sum and Nat.
berghofe
parents: 7283
diff changeset
  2311
\subsection{Representing existing types as datatypes}\label{subsec:datatype:rep_datatype}
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2312
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2313
For foundational reasons, some basic types such as \texttt{nat}, \texttt{*}, {\tt
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2314
  +}, \texttt{bool} and \texttt{unit} are not defined in a \texttt{datatype} section,
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2315
but by more primitive means using \texttt{typedef}. To be able to use the
8443
0ed4b608ba4b renamed cases_tac to case_tac;
wenzelm
parents: 8424
diff changeset
  2316
tactics \texttt{induct_tac} and \texttt{case_tac} and to define functions by
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2317
primitive recursion on these types, such types may be represented as actual
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2318
datatypes.  This is done by specifying an induction rule, as well as theorems
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2319
stating the distinctness and injectivity of constructors in a {\tt
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2320
  rep_datatype} section.  For type \texttt{nat} this works as follows:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2321
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2322
rep_datatype nat
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2323
  distinct Suc_not_Zero, Zero_not_Suc
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2324
  inject   Suc_Suc_eq
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2325
  induct   nat_induct
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2326
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2327
The datatype package automatically derives additional theorems for recursion
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2328
and case combinators from these rules.  Any of the basic HOL types mentioned
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2329
above are represented as datatypes.  Try an induction on \texttt{bool}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2330
today.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2331
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2332
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2333
\subsection{Examples}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2334
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2335
\subsubsection{The datatype $\alpha~mylist$}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2336
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2337
We want to define a type $\alpha~mylist$. To do this we have to build a new
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2338
theory that contains the type definition.  We start from the theory
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2339
\texttt{Datatype} instead of \texttt{Main} in order to avoid clashes with the
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2340
\texttt{List} theory of Isabelle/HOL.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2341
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2342
MyList = Datatype +
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2343
  datatype 'a mylist = Nil | Cons 'a ('a mylist)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2344
end
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2345
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2346
After loading the theory, we can prove $Cons~x~xs\neq xs$, for example.  To
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2347
ease the induction applied below, we state the goal with $x$ quantified at the
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2348
object-level.  This will be stripped later using \ttindex{qed_spec_mp}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2349
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2350
Goal "!x. Cons x xs ~= xs";
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2351
{\out Level 0}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2352
{\out ! x. Cons x xs ~= xs}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2353
{\out  1. ! x. Cons x xs ~= xs}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2354
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2355
This can be proved by the structural induction tactic:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2356
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2357
by (induct_tac "xs" 1);
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2358
{\out Level 1}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2359
{\out ! x. Cons x xs ~= xs}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2360
{\out  1. ! x. Cons x Nil ~= Nil}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2361
{\out  2. !!a mylist.}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2362
{\out        ! x. Cons x mylist ~= mylist ==>}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2363
{\out        ! x. Cons x (Cons a mylist) ~= Cons a mylist}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2364
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2365
The first subgoal can be proved using the simplifier.  Isabelle/HOL has
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2366
already added the freeness properties of lists to the default simplification
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2367
set.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2368
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2369
by (Simp_tac 1);
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2370
{\out Level 2}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2371
{\out ! x. Cons x xs ~= xs}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2372
{\out  1. !!a mylist.}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2373
{\out        ! x. Cons x mylist ~= mylist ==>}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2374
{\out        ! x. Cons x (Cons a mylist) ~= Cons a mylist}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2375
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2376
Similarly, we prove the remaining goal.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2377
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2378
by (Asm_simp_tac 1);
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2379
{\out Level 3}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2380
{\out ! x. Cons x xs ~= xs}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2381
{\out No subgoals!}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2382
\ttbreak
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2383
qed_spec_mp "not_Cons_self";
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2384
{\out val not_Cons_self = "Cons x xs ~= xs" : thm}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2385
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2386
Because both subgoals could have been proved by \texttt{Asm_simp_tac}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2387
we could have done that in one step:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2388
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2389
by (ALLGOALS Asm_simp_tac);
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2390
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2391
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2392
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2393
\subsubsection{The datatype $\alpha~mylist$ with mixfix syntax}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2394
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2395
In this example we define the type $\alpha~mylist$ again but this time
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2396
we want to write \texttt{[]} for \texttt{Nil} and we want to use infix
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2397
notation \verb|#| for \texttt{Cons}.  To do this we simply add mixfix
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2398
annotations after the constructor declarations as follows:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2399
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2400
MyList = Datatype +
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2401
  datatype 'a mylist =
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2402
    Nil ("[]")  |
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2403
    Cons 'a ('a mylist)  (infixr "#" 70)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2404
end
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2405
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2406
Now the theorem in the previous example can be written \verb|x#xs ~= xs|.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2407
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2408
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2409
\subsubsection{A datatype for weekdays}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2410
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2411
This example shows a datatype that consists of 7 constructors:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2412
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2413
Days = Main +
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2414
  datatype days = Mon | Tue | Wed | Thu | Fri | Sat | Sun
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2415
end
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2416
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2417
Because there are more than 6 constructors, inequality is expressed via a function
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2418
\verb|days_ord|.  The theorem \verb|Mon ~= Tue| is not directly
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2419
contained among the distinctness theorems, but the simplifier can
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2420
prove it thanks to rewrite rules inherited from theory \texttt{Arith}:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2421
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2422
Goal "Mon ~= Tue";
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2423
by (Simp_tac 1);
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2424
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2425
You need not derive such inequalities explicitly: the simplifier will dispose
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2426
of them automatically.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2427
\index{*datatype|)}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2428
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2429
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2430
\section{Recursive function definitions}\label{sec:HOL:recursive}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2431
\index{recursive functions|see{recursion}}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2432
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2433
Isabelle/HOL provides two main mechanisms of defining recursive functions.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2434
\begin{enumerate}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2435
\item \textbf{Primitive recursion} is available only for datatypes, and it is
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2436
  somewhat restrictive.  Recursive calls are only allowed on the argument's
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2437
  immediate constituents.  On the other hand, it is the form of recursion most
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2438
  often wanted, and it is easy to use.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2439
  
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2440
\item \textbf{Well-founded recursion} requires that you supply a well-founded
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2441
  relation that governs the recursion.  Recursive calls are only allowed if
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2442
  they make the argument decrease under the relation.  Complicated recursion
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2443
  forms, such as nested recursion, can be dealt with.  Termination can even be
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2444
  proved at a later time, though having unsolved termination conditions around
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2445
  can make work difficult.%
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2446
  \footnote{This facility is based on Konrad Slind's TFL
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2447
    package~\cite{slind-tfl}.  Thanks are due to Konrad for implementing TFL
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2448
    and assisting with its installation.}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2449
\end{enumerate}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2450
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2451
Following good HOL tradition, these declarations do not assert arbitrary
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2452
axioms.  Instead, they define the function using a recursion operator.  Both
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2453
HOL and ZF derive the theory of well-founded recursion from first
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2454
principles~\cite{paulson-set-II}.  Primitive recursion over some datatype
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2455
relies on the recursion operator provided by the datatype package.  With
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2456
either form of function definition, Isabelle proves the desired recursion
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2457
equations as theorems.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2458
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2459
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2460
\subsection{Primitive recursive functions}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2461
\label{sec:HOL:primrec}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2462
\index{recursion!primitive|(}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2463
\index{*primrec|(}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2464
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2465
Datatypes come with a uniform way of defining functions, {\bf primitive
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2466
  recursion}.  In principle, one could introduce primitive recursive functions
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2467
by asserting their reduction rules as new axioms, but this is not recommended:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2468
\begin{ttbox}\slshape
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2469
Append = Main +
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2470
consts app :: ['a list, 'a list] => 'a list
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2471
rules 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2472
   app_Nil   "app [] ys = ys"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2473
   app_Cons  "app (x#xs) ys = x#app xs ys"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2474
end
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2475
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2476
Asserting axioms brings the danger of accidentally asserting nonsense, as
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2477
in \verb$app [] ys = us$.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2478
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2479
The \ttindex{primrec} declaration is a safe means of defining primitive
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2480
recursive functions on datatypes:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2481
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2482
Append = Main +
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2483
consts app :: ['a list, 'a list] => 'a list
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2484
primrec
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2485
   "app [] ys = ys"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2486
   "app (x#xs) ys = x#app xs ys"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2487
end
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2488
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2489
Isabelle will now check that the two rules do indeed form a primitive
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2490
recursive definition.  For example
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2491
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2492
primrec
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2493
    "app [] ys = us"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2494
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2495
is rejected with an error message ``\texttt{Extra variables on rhs}''.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2496
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2497
\bigskip
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2498
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2499
The general form of a primitive recursive definition is
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2500
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2501
primrec
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2502
    {\it reduction rules}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2503
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2504
where \textit{reduction rules} specify one or more equations of the form
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2505
\[ f \, x@1 \, \dots \, x@m \, (C \, y@1 \, \dots \, y@k) \, z@1 \,
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2506
\dots \, z@n = r \] such that $C$ is a constructor of the datatype, $r$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2507
contains only the free variables on the left-hand side, and all recursive
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2508
calls in $r$ are of the form $f \, \dots \, y@i \, \dots$ for some $i$.  There
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2509
must be at most one reduction rule for each constructor.  The order is
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2510
immaterial.  For missing constructors, the function is defined to return a
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2511
default value.  
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2512
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2513
If you would like to refer to some rule by name, then you must prefix
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2514
the rule with an identifier.  These identifiers, like those in the
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2515
\texttt{rules} section of a theory, will be visible at the \ML\ level.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2516
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2517
The primitive recursive function can have infix or mixfix syntax:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2518
\begin{ttbox}\underscoreon
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2519
consts "@"  :: ['a list, 'a list] => 'a list  (infixr 60)
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2520
primrec
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2521
   "[] @ ys = ys"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2522
   "(x#xs) @ ys = x#(xs @ ys)"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2523
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2524
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2525
The reduction rules become part of the default simpset, which
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2526
leads to short proof scripts:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2527
\begin{ttbox}\underscoreon
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2528
Goal "(xs @ ys) @ zs = xs @ (ys @ zs)";
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2529
by (induct\_tac "xs" 1);
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2530
by (ALLGOALS Asm\_simp\_tac);
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2531
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2532
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2533
\subsubsection{Example: Evaluation of expressions}
7044
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2534
Using mutual primitive recursion, we can define evaluation functions \texttt{evala}
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2535
and \texttt{eval_bexp} for the datatypes of arithmetic and boolean expressions mentioned in
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
  2536
{\S}\ref{subsec:datatype:basics}:
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2537
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2538
consts
7044
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2539
  evala :: "['a => nat, 'a aexp] => nat"
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2540
  evalb :: "['a => nat, 'a bexp] => bool"
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2541
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2542
primrec
7044
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2543
  "evala env (If_then_else b a1 a2) =
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2544
     (if evalb env b then evala env a1 else evala env a2)"
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2545
  "evala env (Sum a1 a2) = evala env a1 + evala env a2"
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2546
  "evala env (Diff a1 a2) = evala env a1 - evala env a2"
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2547
  "evala env (Var v) = env v"
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2548
  "evala env (Num n) = n"
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2549
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2550
  "evalb env (Less a1 a2) = (evala env a1 < evala env a2)"
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2551
  "evalb env (And b1 b2) = (evalb env b1 & evalb env b2)"
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2552
  "evalb env (Or b1 b2) = (evalb env b1 & evalb env b2)"
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2553
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2554
Since the value of an expression depends on the value of its variables,
7044
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2555
the functions \texttt{evala} and \texttt{evalb} take an additional
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2556
parameter, an {\em environment} of type \texttt{'a => nat}, which maps
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2557
variables to their values.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2558
7044
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2559
Similarly, we may define substitution functions \texttt{substa}
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2560
and \texttt{substb} for expressions: The mapping \texttt{f} of type
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2561
\texttt{'a => 'a aexp} given as a parameter is lifted canonically
7044
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2562
on the types \texttt{'a aexp} and \texttt{'a bexp}:
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2563
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2564
consts
7044
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2565
  substa :: "['a => 'b aexp, 'a aexp] => 'b aexp"
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2566
  substb :: "['a => 'b aexp, 'a bexp] => 'b bexp"
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2567
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2568
primrec
7044
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2569
  "substa f (If_then_else b a1 a2) =
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2570
     If_then_else (substb f b) (substa f a1) (substa f a2)"
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2571
  "substa f (Sum a1 a2) = Sum (substa f a1) (substa f a2)"
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2572
  "substa f (Diff a1 a2) = Diff (substa f a1) (substa f a2)"
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2573
  "substa f (Var v) = f v"
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2574
  "substa f (Num n) = Num n"
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2575
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2576
  "substb f (Less a1 a2) = Less (substa f a1) (substa f a2)"
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2577
  "substb f (And b1 b2) = And (substb f b1) (substb f b2)"
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2578
  "substb f (Or b1 b2) = Or (substb f b1) (substb f b2)"
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2579
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2580
In textbooks about semantics one often finds {\em substitution theorems},
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2581
which express the relationship between substitution and evaluation. For
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2582
\texttt{'a aexp} and \texttt{'a bexp}, we can prove such a theorem by mutual
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2583
induction, followed by simplification:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2584
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2585
Goal
7044
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2586
  "evala env (substa (Var(v := a')) a) =
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2587
     evala (env(v := evala env a')) a &
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2588
   evalb env (substb (Var(v := a')) b) =
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2589
     evalb (env(v := evala env a')) b";
7846
adf6b1112bc1 Eliminated mutual_induct_tac.
berghofe
parents: 7830
diff changeset
  2590
by (induct_tac "a b" 1);
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2591
by (ALLGOALS Asm_full_simp_tac);
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2592
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2593
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2594
\subsubsection{Example: A substitution function for terms}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2595
Functions on datatypes with nested recursion, such as the type
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
  2596
\texttt{term} mentioned in {\S}\ref{subsec:datatype:basics}, are
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2597
also defined by mutual primitive recursion. A substitution
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2598
function \texttt{subst_term} on type \texttt{term}, similar to the functions
7044
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2599
\texttt{substa} and \texttt{substb} described above, can
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2600
be defined as follows:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2601
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2602
consts
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  2603
  subst_term :: "['a => ('a,'b) term, ('a,'b) term] => ('a,'b) term"
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2604
  subst_term_list ::
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  2605
    "['a => ('a,'b) term, ('a,'b) term list] => ('a,'b) term list"
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2606
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2607
primrec
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2608
  "subst_term f (Var a) = f a"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2609
  "subst_term f (App b ts) = App b (subst_term_list f ts)"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2610
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2611
  "subst_term_list f [] = []"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2612
  "subst_term_list f (t # ts) =
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2613
     subst_term f t # subst_term_list f ts"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2614
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2615
The recursion scheme follows the structure of the unfolded definition of type
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
  2616
\texttt{term} shown in {\S}\ref{subsec:datatype:basics}. To prove properties of
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2617
this substitution function, mutual induction is needed:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2618
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2619
Goal
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2620
  "(subst_term ((subst_term f1) o f2) t) =
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2621
     (subst_term f1 (subst_term f2 t)) &
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2622
   (subst_term_list ((subst_term f1) o f2) ts) =
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2623
     (subst_term_list f1 (subst_term_list f2 ts))";
7846
adf6b1112bc1 Eliminated mutual_induct_tac.
berghofe
parents: 7830
diff changeset
  2624
by (induct_tac "t ts" 1);
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2625
by (ALLGOALS Asm_full_simp_tac);
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2626
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2627
7044
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2628
\subsubsection{Example: A map function for infinitely branching trees}
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2629
Defining functions on infinitely branching datatypes by primitive
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2630
recursion is just as easy. For example, we can define a function
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2631
\texttt{map_tree} on \texttt{'a tree} as follows:
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2632
\begin{ttbox}
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2633
consts
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2634
  map_tree :: "('a => 'b) => 'a tree => 'b tree"
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2635
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2636
primrec
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2637
  "map_tree f (Atom a) = Atom (f a)"
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2638
  "map_tree f (Branch ts) = Branch (\%x. map_tree f (ts x))"
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2639
\end{ttbox}
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2640
Note that all occurrences of functions such as \texttt{ts} in the
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2641
\texttt{primrec} clauses must be applied to an argument. In particular,
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2642
\texttt{map_tree f o ts} is not allowed.
193a8601fabd Documented usage of function types in datatype specifications.
berghofe
parents: 6626
diff changeset
  2643
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2644
\index{recursion!primitive|)}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2645
\index{*primrec|)}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2646
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2647
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2648
\subsection{General recursive functions}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2649
\label{sec:HOL:recdef}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2650
\index{recursion!general|(}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2651
\index{*recdef|(}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2652
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2653
Using \texttt{recdef}, you can declare functions involving nested recursion
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2654
and pattern-matching.  Recursion need not involve datatypes and there are few
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2655
syntactic restrictions.  Termination is proved by showing that each recursive
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2656
call makes the argument smaller in a suitable sense, which you specify by
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2657
supplying a well-founded relation.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2658
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2659
Here is a simple example, the Fibonacci function.  The first line declares
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2660
\texttt{fib} to be a constant.  The well-founded relation is simply~$<$ (on
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2661
the natural numbers).  Pattern-matching is used here: \texttt{1} is a
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2662
macro for \texttt{Suc~0}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2663
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2664
consts fib  :: "nat => nat"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2665
recdef fib "less_than"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2666
    "fib 0 = 0"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2667
    "fib 1 = 1"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2668
    "fib (Suc(Suc x)) = (fib x + fib (Suc x))"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2669
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2670
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2671
With \texttt{recdef}, function definitions may be incomplete, and patterns may
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2672
overlap, as in functional programming.  The \texttt{recdef} package
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2673
disambiguates overlapping patterns by taking the order of rules into account.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2674
For missing patterns, the function is defined to return a default value.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2675
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2676
%For example, here is a declaration of the list function \cdx{hd}:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2677
%\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2678
%consts hd :: 'a list => 'a
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2679
%recdef hd "\{\}"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2680
%    "hd (x#l) = x"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2681
%\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2682
%Because this function is not recursive, we may supply the empty well-founded
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2683
%relation, $\{\}$.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2684
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2685
The well-founded relation defines a notion of ``smaller'' for the function's
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2686
argument type.  The relation $\prec$ is \textbf{well-founded} provided it
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2687
admits no infinitely decreasing chains
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2688
\[ \cdots\prec x@n\prec\cdots\prec x@1. \]
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2689
If the function's argument has type~$\tau$, then $\prec$ has to be a relation
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2690
over~$\tau$: it must have type $(\tau\times\tau)set$.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2691
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2692
Proving well-foundedness can be tricky, so Isabelle/HOL provides a collection
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2693
of operators for building well-founded relations.  The package recognises
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2694
these operators and automatically proves that the constructed relation is
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2695
well-founded.  Here are those operators, in order of importance:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2696
\begin{itemize}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2697
\item \texttt{less_than} is ``less than'' on the natural numbers.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2698
  (It has type $(nat\times nat)set$, while $<$ has type $[nat,nat]\To bool$.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2699
  
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2700
\item $\mathop{\mathtt{measure}} f$, where $f$ has type $\tau\To nat$, is the
9258
2121ff73a37d fixed typos reported by Jeremy Dawson
paulson
parents: 9212
diff changeset
  2701
  relation~$\prec$ on type~$\tau$ such that $x\prec y$ if and only if
2121ff73a37d fixed typos reported by Jeremy Dawson
paulson
parents: 9212
diff changeset
  2702
  $f(x)<f(y)$.  
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2703
  Typically, $f$ takes the recursive function's arguments (as a tuple) and
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2704
  returns a result expressed in terms of the function \texttt{size}.  It is
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2705
  called a \textbf{measure function}.  Recall that \texttt{size} is overloaded
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
  2706
  and is defined on all datatypes (see {\S}\ref{sec:HOL:size}).
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2707
                                                    
9258
2121ff73a37d fixed typos reported by Jeremy Dawson
paulson
parents: 9212
diff changeset
  2708
\item $\mathop{\mathtt{inv_image}} R\;f$ is a generalisation of
2121ff73a37d fixed typos reported by Jeremy Dawson
paulson
parents: 9212
diff changeset
  2709
  \texttt{measure}.  It specifies a relation such that $x\prec y$ if and only
2121ff73a37d fixed typos reported by Jeremy Dawson
paulson
parents: 9212
diff changeset
  2710
  if $f(x)$ 
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2711
  is less than $f(y)$ according to~$R$, which must itself be a well-founded
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2712
  relation.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2713
11242
81fe09ce5fc9 lexicographic product of two relations: updated HOL.tex
paulson
parents: 10109
diff changeset
  2714
\item $R@1\texttt{<*lex*>}R@2$ is the lexicographic product of two relations.
81fe09ce5fc9 lexicographic product of two relations: updated HOL.tex
paulson
parents: 10109
diff changeset
  2715
  It 
9258
2121ff73a37d fixed typos reported by Jeremy Dawson
paulson
parents: 9212
diff changeset
  2716
  is a relation on pairs and satisfies $(x@1,x@2)\prec(y@1,y@2)$ if and only
2121ff73a37d fixed typos reported by Jeremy Dawson
paulson
parents: 9212
diff changeset
  2717
  if $x@1$ 
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2718
  is less than $y@1$ according to~$R@1$ or $x@1=y@1$ and $x@2$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2719
  is less than $y@2$ according to~$R@2$.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2720
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2721
\item \texttt{finite_psubset} is the proper subset relation on finite sets.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2722
\end{itemize}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2723
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2724
We can use \texttt{measure} to declare Euclid's algorithm for the greatest
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2725
common divisor.  The measure function, $\lambda(m,n). n$, specifies that the
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2726
recursion terminates because argument~$n$ decreases.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2727
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2728
recdef gcd "measure ((\%(m,n). n) ::nat*nat=>nat)"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2729
    "gcd (m, n) = (if n=0 then m else gcd(n, m mod n))"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2730
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2731
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2732
The general form of a well-founded recursive definition is
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2733
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2734
recdef {\it function} {\it rel}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2735
    congs   {\it congruence rules}      {\bf(optional)}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2736
    simpset {\it simplification set}      {\bf(optional)}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2737
   {\it reduction rules}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2738
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2739
where
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2740
\begin{itemize}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2741
\item \textit{function} is the name of the function, either as an \textit{id}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2742
  or a \textit{string}.  
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2743
  
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  2744
\item \textit{rel} is a HOL expression for the well-founded termination
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2745
  relation.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2746
  
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2747
\item \textit{congruence rules} are required only in highly exceptional
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2748
  circumstances.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2749
  
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2750
\item The \textit{simplification set} is used to prove that the supplied
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2751
  relation is well-founded.  It is also used to prove the \textbf{termination
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2752
    conditions}: assertions that arguments of recursive calls decrease under
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2753
  \textit{rel}.  By default, simplification uses \texttt{simpset()}, which
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2754
  is sufficient to prove well-foundedness for the built-in relations listed
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2755
  above. 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2756
  
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2757
\item \textit{reduction rules} specify one or more recursion equations.  Each
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2758
  left-hand side must have the form $f\,t$, where $f$ is the function and $t$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2759
  is a tuple of distinct variables.  If more than one equation is present then
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2760
  $f$ is defined by pattern-matching on components of its argument whose type
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2761
  is a \texttt{datatype}.  
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2762
8628
b3d9d8446473 updated recdef
nipkow
parents: 8604
diff changeset
  2763
  The \ML\ identifier $f$\texttt{.simps} contains the reduction rules as
b3d9d8446473 updated recdef
nipkow
parents: 8604
diff changeset
  2764
  a list of theorems.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2765
\end{itemize}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2766
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2767
With the definition of \texttt{gcd} shown above, Isabelle/HOL is unable to
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2768
prove one termination condition.  It remains as a precondition of the
8628
b3d9d8446473 updated recdef
nipkow
parents: 8604
diff changeset
  2769
recursion theorems:
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2770
\begin{ttbox}
8628
b3d9d8446473 updated recdef
nipkow
parents: 8604
diff changeset
  2771
gcd.simps;
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2772
{\out ["! m n. n ~= 0 --> m mod n < n}
9212
4afe62073b41 overloading, axclasses, numerals and general tidying
paulson
parents: 8628
diff changeset
  2773
{\out   ==> gcd (?m,?n) = (if ?n=0 then ?m else gcd (?n, ?m mod ?n))"] }
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2774
{\out : thm list}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2775
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2776
The theory \texttt{HOL/ex/Primes} illustrates how to prove termination
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2777
conditions afterwards.  The function \texttt{Tfl.tgoalw} is like the standard
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2778
function \texttt{goalw}, which sets up a goal to prove, but its argument
8628
b3d9d8446473 updated recdef
nipkow
parents: 8604
diff changeset
  2779
should be the identifier $f$\texttt{.simps} and its effect is to set up a
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2780
proof of the termination conditions:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2781
\begin{ttbox}
8628
b3d9d8446473 updated recdef
nipkow
parents: 8604
diff changeset
  2782
Tfl.tgoalw thy [] gcd.simps;
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2783
{\out Level 0}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2784
{\out ! m n. n ~= 0 --> m mod n < n}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2785
{\out  1. ! m n. n ~= 0 --> m mod n < n}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2786
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2787
This subgoal has a one-step proof using \texttt{simp_tac}.  Once the theorem
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2788
is proved, it can be used to eliminate the termination conditions from
8628
b3d9d8446473 updated recdef
nipkow
parents: 8604
diff changeset
  2789
elements of \texttt{gcd.simps}.  Theory \texttt{HOL/Subst/Unify} is a much
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2790
more complicated example of this process, where the termination conditions can
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2791
only be proved by complicated reasoning involving the recursive function
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2792
itself.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2793
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2794
Isabelle/HOL can prove the \texttt{gcd} function's termination condition
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2795
automatically if supplied with the right simpset.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2796
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2797
recdef gcd "measure ((\%(m,n). n) ::nat*nat=>nat)"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2798
  simpset "simpset() addsimps [mod_less_divisor, zero_less_eq]"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2799
    "gcd (m, n) = (if n=0 then m else gcd(n, m mod n))"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2800
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2801
8628
b3d9d8446473 updated recdef
nipkow
parents: 8604
diff changeset
  2802
If all termination conditions were proved automatically, $f$\texttt{.simps}
b3d9d8446473 updated recdef
nipkow
parents: 8604
diff changeset
  2803
is added to the simpset automatically, just as in \texttt{primrec}. 
b3d9d8446473 updated recdef
nipkow
parents: 8604
diff changeset
  2804
The simplification rules corresponding to clause $i$ (where counting starts
b3d9d8446473 updated recdef
nipkow
parents: 8604
diff changeset
  2805
at 0) are called $f$\texttt{.}$i$ and can be accessed as \texttt{thms
b3d9d8446473 updated recdef
nipkow
parents: 8604
diff changeset
  2806
  "$f$.$i$"},
b3d9d8446473 updated recdef
nipkow
parents: 8604
diff changeset
  2807
which returns a list of theorems. Thus you can, for example, remove specific
b3d9d8446473 updated recdef
nipkow
parents: 8604
diff changeset
  2808
clauses from the simpset. Note that a single clause may give rise to a set of
b3d9d8446473 updated recdef
nipkow
parents: 8604
diff changeset
  2809
simplification rules in order to capture the fact that if clauses overlap,
b3d9d8446473 updated recdef
nipkow
parents: 8604
diff changeset
  2810
their order disambiguates them.
b3d9d8446473 updated recdef
nipkow
parents: 8604
diff changeset
  2811
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2812
A \texttt{recdef} definition also returns an induction rule specialised for
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2813
the recursive function.  For the \texttt{gcd} function above, the induction
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2814
rule is
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2815
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2816
gcd.induct;
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2817
{\out "(!!m n. n ~= 0 --> ?P n (m mod n) ==> ?P m n) ==> ?P ?u ?v" : thm}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2818
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2819
This rule should be used to reason inductively about the \texttt{gcd}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2820
function.  It usually makes the induction hypothesis available at all
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2821
recursive calls, leading to very direct proofs.  If any termination conditions
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2822
remain unproved, they will become additional premises of this rule.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2823
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2824
\index{recursion!general|)}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2825
\index{*recdef|)}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2826
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2827
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2828
\section{Inductive and coinductive definitions}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2829
\index{*inductive|(}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2830
\index{*coinductive|(}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2831
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2832
An {\bf inductive definition} specifies the least set~$R$ closed under given
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2833
rules.  (Applying a rule to elements of~$R$ yields a result within~$R$.)  For
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2834
example, a structural operational semantics is an inductive definition of an
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2835
evaluation relation.  Dually, a {\bf coinductive definition} specifies the
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2836
greatest set~$R$ consistent with given rules.  (Every element of~$R$ can be
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2837
seen as arising by applying a rule to elements of~$R$.)  An important example
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2838
is using bisimulation relations to formalise equivalence of processes and
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2839
infinite data structures.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2840
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2841
A theory file may contain any number of inductive and coinductive
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2842
definitions.  They may be intermixed with other declarations; in
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2843
particular, the (co)inductive sets {\bf must} be declared separately as
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2844
constants, and may have mixfix syntax or be subject to syntax translations.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2845
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2846
Each (co)inductive definition adds definitions to the theory and also
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2847
proves some theorems.  Each definition creates an \ML\ structure, which is a
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2848
substructure of the main theory structure.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2849
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  2850
This package is related to the ZF one, described in a separate
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2851
paper,%
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2852
\footnote{It appeared in CADE~\cite{paulson-CADE}; a longer version is
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2853
  distributed with Isabelle.}  %
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2854
which you should refer to in case of difficulties.  The package is simpler
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  2855
than ZF's thanks to HOL's extra-logical automatic type-checking.  The types of
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  2856
the (co)inductive sets determine the domain of the fixedpoint definition, and
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  2857
the package does not have to use inference rules for type-checking.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2858
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2859
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2860
\subsection{The result structure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2861
Many of the result structure's components have been discussed in the paper;
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2862
others are self-explanatory.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2863
\begin{description}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2864
\item[\tt defs] is the list of definitions of the recursive sets.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2865
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2866
\item[\tt mono] is a monotonicity theorem for the fixedpoint operator.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2867
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2868
\item[\tt unfold] is a fixedpoint equation for the recursive set (the union of
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2869
the recursive sets, in the case of mutual recursion).
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2870
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2871
\item[\tt intrs] is the list of introduction rules, now proved as theorems, for
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2872
the recursive sets.  The rules are also available individually, using the
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2873
names given them in the theory file. 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2874
10109
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  2875
\item[\tt elims] is the list of elimination rule.  This is for compatibility
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  2876
  with ML scripts; within the theory the name is \texttt{cases}.
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  2877
  
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  2878
\item[\tt elim] is the head of the list \texttt{elims}.  This is for
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  2879
  compatibility only.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2880
  
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2881
\item[\tt mk_cases] is a function to create simplified instances of {\tt
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2882
elim} using freeness reasoning on underlying datatypes.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2883
\end{description}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2884
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2885
For an inductive definition, the result structure contains the
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2886
rule \texttt{induct}.  For a
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2887
coinductive definition, it contains the rule \verb|coinduct|.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2888
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2889
Figure~\ref{def-result-fig} summarises the two result signatures,
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2890
specifying the types of all these components.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2891
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2892
\begin{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2893
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2894
sig
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2895
val defs         : thm list
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2896
val mono         : thm
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2897
val unfold       : thm
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2898
val intrs        : thm list
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2899
val elims        : thm list
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2900
val elim         : thm
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2901
val mk_cases     : string -> thm
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2902
{\it(Inductive definitions only)} 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2903
val induct       : thm
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2904
{\it(coinductive definitions only)}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2905
val coinduct     : thm
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2906
end
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2907
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2908
\hrule
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2909
\caption{The {\ML} result of a (co)inductive definition} \label{def-result-fig}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2910
\end{figure}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2911
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2912
\subsection{The syntax of a (co)inductive definition}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2913
An inductive definition has the form
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2914
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2915
inductive    {\it inductive sets}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2916
  intrs      {\it introduction rules}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2917
  monos      {\it monotonicity theorems}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2918
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2919
A coinductive definition is identical, except that it starts with the keyword
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2920
\texttt{coinductive}.  
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2921
12180
91c9f661b183 inductive: removed con_defs;
wenzelm
parents: 11242
diff changeset
  2922
The \texttt{monos} section is optional; if present it is specified by a list
91c9f661b183 inductive: removed con_defs;
wenzelm
parents: 11242
diff changeset
  2923
of identifiers.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2924
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2925
\begin{itemize}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2926
\item The \textit{inductive sets} are specified by one or more strings.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2927
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2928
\item The \textit{introduction rules} specify one or more introduction rules in
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2929
  the form \textit{ident\/}~\textit{string}, where the identifier gives the name of
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2930
  the rule in the result structure.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2931
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2932
\item The \textit{monotonicity theorems} are required for each operator
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2933
  applied to a recursive set in the introduction rules.  There {\bf must}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2934
  be a theorem of the form $A\subseteq B\Imp M(A)\subseteq M(B)$, for each
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2935
  premise $t\in M(R@i)$ in an introduction rule!
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2936
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2937
\item The \textit{constructor definitions} contain definitions of constants
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2938
  appearing in the introduction rules.  In most cases it can be omitted.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2939
\end{itemize}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2940
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2941
7830
bd97236cbc02 - Documented monotonicity theorems.
berghofe
parents: 7490
diff changeset
  2942
\subsection{*Monotonicity theorems}
bd97236cbc02 - Documented monotonicity theorems.
berghofe
parents: 7490
diff changeset
  2943
bd97236cbc02 - Documented monotonicity theorems.
berghofe
parents: 7490
diff changeset
  2944
Each theory contains a default set of theorems that are used in monotonicity
bd97236cbc02 - Documented monotonicity theorems.
berghofe
parents: 7490
diff changeset
  2945
proofs. New rules can be added to this set via the \texttt{mono} attribute.
bd97236cbc02 - Documented monotonicity theorems.
berghofe
parents: 7490
diff changeset
  2946
Theory \texttt{Inductive} shows how this is done. In general, the following
bd97236cbc02 - Documented monotonicity theorems.
berghofe
parents: 7490
diff changeset
  2947
monotonicity theorems may be added:
bd97236cbc02 - Documented monotonicity theorems.
berghofe
parents: 7490
diff changeset
  2948
\begin{itemize}
bd97236cbc02 - Documented monotonicity theorems.
berghofe
parents: 7490
diff changeset
  2949
\item Theorems of the form $A\subseteq B\Imp M(A)\subseteq M(B)$, for proving
bd97236cbc02 - Documented monotonicity theorems.
berghofe
parents: 7490
diff changeset
  2950
  monotonicity of inductive definitions whose introduction rules have premises
bd97236cbc02 - Documented monotonicity theorems.
berghofe
parents: 7490
diff changeset
  2951
  involving terms such as $t\in M(R@i)$.
bd97236cbc02 - Documented monotonicity theorems.
berghofe
parents: 7490
diff changeset
  2952
\item Monotonicity theorems for logical operators, which are of the general form
11242
81fe09ce5fc9 lexicographic product of two relations: updated HOL.tex
paulson
parents: 10109
diff changeset
  2953
  $\List{\cdots \to \cdots;~\ldots;~\cdots \to \cdots} \Imp
81fe09ce5fc9 lexicographic product of two relations: updated HOL.tex
paulson
parents: 10109
diff changeset
  2954
    \cdots \to \cdots$.
81fe09ce5fc9 lexicographic product of two relations: updated HOL.tex
paulson
parents: 10109
diff changeset
  2955
  For example, in the case of the operator $\lor$, the corresponding theorem is
7830
bd97236cbc02 - Documented monotonicity theorems.
berghofe
parents: 7490
diff changeset
  2956
  \[
11242
81fe09ce5fc9 lexicographic product of two relations: updated HOL.tex
paulson
parents: 10109
diff changeset
  2957
  \infer{P@1 \lor P@2 \to Q@1 \lor Q@2}
81fe09ce5fc9 lexicographic product of two relations: updated HOL.tex
paulson
parents: 10109
diff changeset
  2958
    {P@1 \to Q@1 & P@2 \to Q@2}
7830
bd97236cbc02 - Documented monotonicity theorems.
berghofe
parents: 7490
diff changeset
  2959
  \]
bd97236cbc02 - Documented monotonicity theorems.
berghofe
parents: 7490
diff changeset
  2960
\item De Morgan style equations for reasoning about the ``polarity'' of expressions, e.g.
bd97236cbc02 - Documented monotonicity theorems.
berghofe
parents: 7490
diff changeset
  2961
  \[
11242
81fe09ce5fc9 lexicographic product of two relations: updated HOL.tex
paulson
parents: 10109
diff changeset
  2962
  (\lnot \lnot P) ~=~ P \qquad\qquad
81fe09ce5fc9 lexicographic product of two relations: updated HOL.tex
paulson
parents: 10109
diff changeset
  2963
  (\lnot (P \land Q)) ~=~ (\lnot P \lor \lnot Q)
7830
bd97236cbc02 - Documented monotonicity theorems.
berghofe
parents: 7490
diff changeset
  2964
  \]
bd97236cbc02 - Documented monotonicity theorems.
berghofe
parents: 7490
diff changeset
  2965
\item Equations for reducing complex operators to more primitive ones whose
bd97236cbc02 - Documented monotonicity theorems.
berghofe
parents: 7490
diff changeset
  2966
  monotonicity can easily be proved, e.g.
bd97236cbc02 - Documented monotonicity theorems.
berghofe
parents: 7490
diff changeset
  2967
  \[
11242
81fe09ce5fc9 lexicographic product of two relations: updated HOL.tex
paulson
parents: 10109
diff changeset
  2968
  (P \to Q) ~=~ (\lnot P \lor Q) \qquad\qquad
81fe09ce5fc9 lexicographic product of two relations: updated HOL.tex
paulson
parents: 10109
diff changeset
  2969
  \mathtt{Ball}~A~P ~\equiv~ \forall x.~x \in A \to P~x
7830
bd97236cbc02 - Documented monotonicity theorems.
berghofe
parents: 7490
diff changeset
  2970
  \]
bd97236cbc02 - Documented monotonicity theorems.
berghofe
parents: 7490
diff changeset
  2971
\end{itemize}
bd97236cbc02 - Documented monotonicity theorems.
berghofe
parents: 7490
diff changeset
  2972
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2973
\subsection{Example of an inductive definition}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2974
Two declarations, included in a theory file, define the finite powerset
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2975
operator.  First we declare the constant~\texttt{Fin}.  Then we declare it
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2976
inductively, with two introduction rules:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2977
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2978
consts Fin :: 'a set => 'a set set
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2979
inductive "Fin A"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2980
  intrs
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2981
    emptyI  "{\ttlbrace}{\ttrbrace} : Fin A"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2982
    insertI "[| a: A;  b: Fin A |] ==> insert a b : Fin A"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2983
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2984
The resulting theory structure contains a substructure, called~\texttt{Fin}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2985
It contains the \texttt{Fin}$~A$ introduction rules as the list \texttt{Fin.intrs},
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2986
and also individually as \texttt{Fin.emptyI} and \texttt{Fin.consI}.  The induction
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2987
rule is \texttt{Fin.induct}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2988
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  2989
For another example, here is a theory file defining the accessible part of a
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  2990
relation.  The paper \cite{paulson-CADE} discusses a ZF version of this
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  2991
example in more detail.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2992
\begin{ttbox}
7830
bd97236cbc02 - Documented monotonicity theorems.
berghofe
parents: 7490
diff changeset
  2993
Acc = WF + Inductive +
bd97236cbc02 - Documented monotonicity theorems.
berghofe
parents: 7490
diff changeset
  2994
bd97236cbc02 - Documented monotonicity theorems.
berghofe
parents: 7490
diff changeset
  2995
consts acc :: "('a * 'a)set => 'a set"   (* accessible part *)
bd97236cbc02 - Documented monotonicity theorems.
berghofe
parents: 7490
diff changeset
  2996
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2997
inductive "acc r"
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  2998
  intrs
7830
bd97236cbc02 - Documented monotonicity theorems.
berghofe
parents: 7490
diff changeset
  2999
    accI "ALL y. (y, x) : r --> y : acc r ==> x : acc r"
bd97236cbc02 - Documented monotonicity theorems.
berghofe
parents: 7490
diff changeset
  3000
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3001
end
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3002
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3003
The Isabelle distribution contains many other inductive definitions.  Simple
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3004
examples are collected on subdirectory \texttt{HOL/Induct}.  The theory
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3005
\texttt{HOL/Induct/LList} contains coinductive definitions.  Larger examples
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3006
may be found on other subdirectories of \texttt{HOL}, such as \texttt{IMP},
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3007
\texttt{Lambda} and \texttt{Auth}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3008
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3009
\index{*coinductive|)} \index{*inductive|)}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3010
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3011
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3012
\section{The examples directories}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3013
6592
c120262044b6 Now uses manual.bib; some references updated
paulson
parents: 6588
diff changeset
  3014
Directory \texttt{HOL/Auth} contains theories for proving the correctness of
c120262044b6 Now uses manual.bib; some references updated
paulson
parents: 6588
diff changeset
  3015
cryptographic protocols~\cite{paulson-jcs}.  The approach is based upon
c120262044b6 Now uses manual.bib; some references updated
paulson
parents: 6588
diff changeset
  3016
operational semantics rather than the more usual belief logics.  On the same
c120262044b6 Now uses manual.bib; some references updated
paulson
parents: 6588
diff changeset
  3017
directory are proofs for some standard examples, such as the Needham-Schroeder
c120262044b6 Now uses manual.bib; some references updated
paulson
parents: 6588
diff changeset
  3018
public-key authentication protocol and the Otway-Rees
c120262044b6 Now uses manual.bib; some references updated
paulson
parents: 6588
diff changeset
  3019
protocol.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3020
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3021
Directory \texttt{HOL/IMP} contains a formalization of various denotational,
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3022
operational and axiomatic semantics of a simple while-language, the necessary
6588
6e6ca099f68f Bibtex stuff.
nipkow
parents: 6580
diff changeset
  3023
equivalence proofs, soundness and completeness of the Hoare rules with
6e6ca099f68f Bibtex stuff.
nipkow
parents: 6580
diff changeset
  3024
respect to the denotational semantics, and soundness and completeness of a
6e6ca099f68f Bibtex stuff.
nipkow
parents: 6580
diff changeset
  3025
verification condition generator.  Much of development is taken from
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3026
Winskel~\cite{winskel93}.  For details see~\cite{nipkow-IMP}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3027
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3028
Directory \texttt{HOL/Hoare} contains a user friendly surface syntax for Hoare
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3029
logic, including a tactic for generating verification-conditions.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3030
6588
6e6ca099f68f Bibtex stuff.
nipkow
parents: 6580
diff changeset
  3031
Directory \texttt{HOL/MiniML} contains a formalization of the type system of
6e6ca099f68f Bibtex stuff.
nipkow
parents: 6580
diff changeset
  3032
the core functional language Mini-ML and a correctness proof for its type
6e6ca099f68f Bibtex stuff.
nipkow
parents: 6580
diff changeset
  3033
inference algorithm $\cal W$~\cite{milner78,nipkow-W}.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3034
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3035
Directory \texttt{HOL/Lambda} contains a formalization of untyped
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3036
$\lambda$-calculus in de~Bruijn notation and Church-Rosser proofs for $\beta$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3037
and $\eta$ reduction~\cite{Nipkow-CR}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3038
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  3039
Directory \texttt{HOL/Subst} contains Martin Coen's mechanization of a theory
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  3040
of substitutions and unifiers.  It is based on Paulson's previous
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  3041
mechanisation in LCF~\cite{paulson85} of Manna and Waldinger's
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3042
theory~\cite{mw81}.  It demonstrates a complicated use of \texttt{recdef},
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3043
with nested recursion.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3044
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3045
Directory \texttt{HOL/Induct} presents simple examples of (co)inductive
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3046
definitions and datatypes.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3047
\begin{itemize}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3048
\item Theory \texttt{PropLog} proves the soundness and completeness of
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3049
  classical propositional logic, given a truth table semantics.  The only
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3050
  connective is $\imp$.  A Hilbert-style axiom system is specified, and its
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  3051
  set of theorems defined inductively.  A similar proof in ZF is described
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  3052
  elsewhere~\cite{paulson-set-II}.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3053
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3054
\item Theory \texttt{Term} defines the datatype \texttt{term}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3055
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3056
\item Theory \texttt{ABexp} defines arithmetic and boolean expressions
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3057
 as mutually recursive datatypes.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3058
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3059
\item The definition of lazy lists demonstrates methods for handling
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3060
  infinite data structures and coinduction in higher-order
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3061
  logic~\cite{paulson-coind}.%
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3062
\footnote{To be precise, these lists are \emph{potentially infinite} rather
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3063
  than lazy.  Lazy implies a particular operational semantics.}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3064
  Theory \thydx{LList} defines an operator for
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3065
  corecursion on lazy lists, which is used to define a few simple functions
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3066
  such as map and append.   A coinduction principle is defined
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3067
  for proving equations on lazy lists.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3068
  
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3069
\item Theory \thydx{LFilter} defines the filter functional for lazy lists.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3070
  This functional is notoriously difficult to define because finding the next
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3071
  element meeting the predicate requires possibly unlimited search.  It is not
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3072
  computable, but can be expressed using a combination of induction and
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3073
  corecursion.  
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3074
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3075
\item Theory \thydx{Exp} illustrates the use of iterated inductive definitions
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3076
  to express a programming language semantics that appears to require mutual
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3077
  induction.  Iterated induction allows greater modularity.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3078
\end{itemize}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3079
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3080
Directory \texttt{HOL/ex} contains other examples and experimental proofs in
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  3081
HOL.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3082
\begin{itemize}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3083
\item Theory \texttt{Recdef} presents many examples of using \texttt{recdef}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3084
  to define recursive functions.  Another example is \texttt{Fib}, which
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3085
  defines the Fibonacci function.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3086
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3087
\item Theory \texttt{Primes} defines the Greatest Common Divisor of two
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3088
  natural numbers and proves a key lemma of the Fundamental Theorem of
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3089
  Arithmetic: if $p$ is prime and $p$ divides $m\times n$ then $p$ divides~$m$
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3090
  or $p$ divides~$n$.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3091
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3092
\item Theory \texttt{Primrec} develops some computation theory.  It
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3093
  inductively defines the set of primitive recursive functions and presents a
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3094
  proof that Ackermann's function is not primitive recursive.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3095
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3096
\item File \texttt{cla.ML} demonstrates the classical reasoner on over sixty
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3097
  predicate calculus theorems, ranging from simple tautologies to
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3098
  moderately difficult problems involving equality and quantifiers.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3099
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3100
\item File \texttt{meson.ML} contains an experimental implementation of the {\sc
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3101
    meson} proof procedure, inspired by Plaisted~\cite{plaisted90}.  It is
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3102
  much more powerful than Isabelle's classical reasoner.  But it is less
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3103
  useful in practice because it works only for pure logic; it does not
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3104
  accept derived rules for the set theory primitives, for example.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3105
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3106
\item File \texttt{mesontest.ML} contains test data for the {\sc meson} proof
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3107
  procedure.  These are mostly taken from Pelletier \cite{pelletier86}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3108
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3109
\item File \texttt{set.ML} proves Cantor's Theorem, which is presented in
7490
9a74b57740d1 added smp_tac
oheimb
parents: 7328
diff changeset
  3110
  {\S}\ref{sec:hol-cantor} below, and the Schr{\"o}der-Bernstein Theorem.
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3111
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3112
\item Theory \texttt{MT} contains Jacob Frost's formalization~\cite{frost93} of
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3113
  Milner and Tofte's coinduction example~\cite{milner-coind}.  This
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3114
  substantial proof concerns the soundness of a type system for a simple
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3115
  functional language.  The semantics of recursion is given by a cyclic
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3116
  environment, which makes a coinductive argument appropriate.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3117
\end{itemize}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3118
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3119
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3120
\goodbreak
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3121
\section{Example: Cantor's Theorem}\label{sec:hol-cantor}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3122
Cantor's Theorem states that every set has more subsets than it has
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3123
elements.  It has become a favourite example in higher-order logic since
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3124
it is so easily expressed:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3125
\[  \forall f::\alpha \To \alpha \To bool. \exists S::\alpha\To bool.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3126
    \forall x::\alpha. f~x \not= S 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3127
\] 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3128
%
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3129
Viewing types as sets, $\alpha\To bool$ represents the powerset
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3130
of~$\alpha$.  This version states that for every function from $\alpha$ to
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3131
its powerset, some subset is outside its range.  
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3132
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  3133
The Isabelle proof uses HOL's set theory, with the type $\alpha\,set$ and
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3134
the operator \cdx{range}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3135
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3136
context Set.thy;
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3137
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3138
The set~$S$ is given as an unknown instead of a
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3139
quantified variable so that we may inspect the subset found by the proof.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3140
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3141
Goal "?S ~: range\thinspace(f :: 'a=>'a set)";
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3142
{\out Level 0}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3143
{\out ?S ~: range f}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3144
{\out  1. ?S ~: range f}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3145
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3146
The first two steps are routine.  The rule \tdx{rangeE} replaces
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3147
$\Var{S}\in \texttt{range} \, f$ by $\Var{S}=f~x$ for some~$x$.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3148
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3149
by (resolve_tac [notI] 1);
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3150
{\out Level 1}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3151
{\out ?S ~: range f}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3152
{\out  1. ?S : range f ==> False}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3153
\ttbreak
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3154
by (eresolve_tac [rangeE] 1);
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3155
{\out Level 2}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3156
{\out ?S ~: range f}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3157
{\out  1. !!x. ?S = f x ==> False}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3158
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3159
Next, we apply \tdx{equalityCE}, reasoning that since $\Var{S}=f~x$,
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3160
we have $\Var{c}\in \Var{S}$ if and only if $\Var{c}\in f~x$ for
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3161
any~$\Var{c}$.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3162
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3163
by (eresolve_tac [equalityCE] 1);
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3164
{\out Level 3}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3165
{\out ?S ~: range f}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3166
{\out  1. !!x. [| ?c3 x : ?S; ?c3 x : f x |] ==> False}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3167
{\out  2. !!x. [| ?c3 x ~: ?S; ?c3 x ~: f x |] ==> False}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3168
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3169
Now we use a bit of creativity.  Suppose that~$\Var{S}$ has the form of a
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3170
comprehension.  Then $\Var{c}\in\{x.\Var{P}~x\}$ implies
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3171
$\Var{P}~\Var{c}$.   Destruct-resolution using \tdx{CollectD}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3172
instantiates~$\Var{S}$ and creates the new assumption.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3173
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3174
by (dresolve_tac [CollectD] 1);
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3175
{\out Level 4}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3176
{\out {\ttlbrace}x. ?P7 x{\ttrbrace} ~: range f}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3177
{\out  1. !!x. [| ?c3 x : f x; ?P7(?c3 x) |] ==> False}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3178
{\out  2. !!x. [| ?c3 x ~: {\ttlbrace}x. ?P7 x{\ttrbrace}; ?c3 x ~: f x |] ==> False}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3179
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3180
Forcing a contradiction between the two assumptions of subgoal~1
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3181
completes the instantiation of~$S$.  It is now the set $\{x. x\not\in
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3182
f~x\}$, which is the standard diagonal construction.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3183
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3184
by (contr_tac 1);
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3185
{\out Level 5}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3186
{\out {\ttlbrace}x. x ~: f x{\ttrbrace} ~: range f}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3187
{\out  1. !!x. [| x ~: {\ttlbrace}x. x ~: f x{\ttrbrace}; x ~: f x |] ==> False}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3188
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3189
The rest should be easy.  To apply \tdx{CollectI} to the negated
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3190
assumption, we employ \ttindex{swap_res_tac}:
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3191
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3192
by (swap_res_tac [CollectI] 1);
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3193
{\out Level 6}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3194
{\out {\ttlbrace}x. x ~: f x{\ttrbrace} ~: range f}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3195
{\out  1. !!x. [| x ~: f x; ~ False |] ==> x ~: f x}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3196
\ttbreak
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3197
by (assume_tac 1);
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3198
{\out Level 7}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3199
{\out {\ttlbrace}x. x ~: f x{\ttrbrace} ~: range f}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3200
{\out No subgoals!}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3201
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3202
How much creativity is required?  As it happens, Isabelle can prove this
9695
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  3203
theorem automatically.  The default classical set \texttt{claset()} contains
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  3204
rules for most of the constructs of HOL's set theory.  We must augment it with
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  3205
\tdx{equalityCE} to break up set equalities, and then apply best-first search.
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  3206
Depth-first search would diverge, but best-first search successfully navigates
ec7d7f877712 proper setup of iman.sty/extra.sty/ttbox.sty;
wenzelm
parents: 9258
diff changeset
  3207
through the large search space.  \index{search!best-first}
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3208
\begin{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3209
choplev 0;
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3210
{\out Level 0}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3211
{\out ?S ~: range f}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3212
{\out  1. ?S ~: range f}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3213
\ttbreak
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3214
by (best_tac (claset() addSEs [equalityCE]) 1);
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3215
{\out Level 1}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3216
{\out {\ttlbrace}x. x ~: f x{\ttrbrace} ~: range f}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3217
{\out No subgoals!}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3218
\end{ttbox}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3219
If you run this example interactively, make sure your current theory contains
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3220
theory \texttt{Set}, for example by executing \ttindex{context}~{\tt Set.thy}.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3221
Otherwise the default claset may not contain the rules for set theory.
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3222
\index{higher-order logic|)}
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3223
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3224
%%% Local Variables: 
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3225
%%% mode: latex
10109
dcb72400bc32 record proof tools: t.equality;
wenzelm
parents: 10052
diff changeset
  3226
%%% TeX-master: "logics-HOL"
6580
ff2c3ffd38ee used to be part of 'logics' manual;
wenzelm
parents:
diff changeset
  3227
%%% End: