author | Fabian Huch <huch@in.tum.de> |
Thu, 28 Mar 2024 15:08:58 +0100 | |
changeset 80058 | 68f6b29ae066 |
parent 76987 | 4c275405faae |
permissions | -rw-r--r-- |
52792 | 1 |
(* Title: Doc/Datatypes/Datatypes.thy |
61303 | 2 |
Author: Julian Biendarra, TU Muenchen |
52792 | 3 |
Author: Jasmin Blanchette, TU Muenchen |
57079 | 4 |
Author: Martin Desharnais, Ecole de technologie superieure |
53617 | 5 |
Author: Lorenz Panny, TU Muenchen |
6 |
Author: Andrei Popescu, TU Muenchen |
|
7 |
Author: Dmitriy Traytel, TU Muenchen |
|
52792 | 8 |
|
58305
57752a91eec4
renamed 'datatype' to 'old_datatype'; 'datatype' is now alias for 'datatype_new'
blanchet
parents:
58298
diff
changeset
|
9 |
Tutorial for (co)datatype definitions. |
52792 | 10 |
*) |
11 |
||
12 |
theory Datatypes |
|
55073 | 13 |
imports |
14 |
Setup |
|
66453
cc19f7ca2ed6
session-qualified theory imports: isabelle imports -U -i -d '~~/src/Benchmarks' -a;
wenzelm
parents:
64939
diff
changeset
|
15 |
"HOL-Library.BNF_Axiomatization" |
cc19f7ca2ed6
session-qualified theory imports: isabelle imports -U -i -d '~~/src/Benchmarks' -a;
wenzelm
parents:
64939
diff
changeset
|
16 |
"HOL-Library.Countable" |
cc19f7ca2ed6
session-qualified theory imports: isabelle imports -U -i -d '~~/src/Benchmarks' -a;
wenzelm
parents:
64939
diff
changeset
|
17 |
"HOL-Library.FSet" |
cc19f7ca2ed6
session-qualified theory imports: isabelle imports -U -i -d '~~/src/Benchmarks' -a;
wenzelm
parents:
64939
diff
changeset
|
18 |
"HOL-Library.Simps_Case_Conv" |
52792 | 19 |
begin |
20 |
||
70078 | 21 |
|
22 |
(*<*) |
|
23 |
unbundle cardinal_syntax |
|
24 |
(*>*) |
|
25 |
||
62731 | 26 |
section \<open>Introduction |
27 |
\label{sec:introduction}\<close> |
|
62081 | 28 |
|
29 |
text \<open> |
|
58305
57752a91eec4
renamed 'datatype' to 'old_datatype'; 'datatype' is now alias for 'datatype_new'
blanchet
parents:
58298
diff
changeset
|
30 |
The 2013 edition of Isabelle introduced a definitional package for freely |
57752a91eec4
renamed 'datatype' to 'old_datatype'; 'datatype' is now alias for 'datatype_new'
blanchet
parents:
58298
diff
changeset
|
31 |
generated datatypes and codatatypes. This package replaces the earlier |
76987 | 32 |
implementation due to Berghofer and Wenzel \<^cite>\<open>"Berghofer-Wenzel:1999:TPHOL"\<close>. |
52841 | 33 |
Perhaps the main advantage of the new package is that it supports recursion |
53619 | 34 |
through a large class of non-datatypes, such as finite sets: |
62081 | 35 |
\<close> |
52792 | 36 |
|
58310 | 37 |
datatype 'a tree\<^sub>f\<^sub>s = Node\<^sub>f\<^sub>s (lbl\<^sub>f\<^sub>s: 'a) (sub\<^sub>f\<^sub>s: "'a tree\<^sub>f\<^sub>s fset") |
52792 | 38 |
|
62081 | 39 |
text \<open> |
52794 | 40 |
\noindent |
53025 | 41 |
Another strong point is the support for local definitions: |
62081 | 42 |
\<close> |
52792 | 43 |
|
52805 | 44 |
context linorder |
45 |
begin |
|
58310 | 46 |
datatype flag = Less | Eq | Greater |
52805 | 47 |
end |
52792 | 48 |
|
62081 | 49 |
text \<open> |
52794 | 50 |
\noindent |
54187 | 51 |
Furthermore, the package provides a lot of convenience, including automatically |
52 |
generated discriminators, selectors, and relators as well as a wealth of |
|
53 |
properties about them. |
|
54 |
||
58305
57752a91eec4
renamed 'datatype' to 'old_datatype'; 'datatype' is now alias for 'datatype_new'
blanchet
parents:
58298
diff
changeset
|
55 |
In addition to inductive datatypes, the package supports coinductive |
54187 | 56 |
datatypes, or \emph{codatatypes}, which allow infinite values. For example, the |
57 |
following command introduces the type of lazy lists, which comprises both finite |
|
58 |
and infinite values: |
|
62081 | 59 |
\<close> |
52794 | 60 |
|
53623 | 61 |
(*<*) |
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
62 |
locale early |
54072 | 63 |
locale late |
53623 | 64 |
(*>*) |
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
65 |
codatatype (*<*)(in early) (*>*)'a llist = LNil | LCons 'a "'a llist" |
52794 | 66 |
|
62081 | 67 |
text \<open> |
52794 | 68 |
\noindent |
52840 | 69 |
Mixed inductive--coinductive recursion is possible via nesting. Compare the |
53028 | 70 |
following four Rose tree examples: |
62081 | 71 |
\<close> |
52794 | 72 |
|
58310 | 73 |
datatype (*<*)(in early) (*>*)'a tree\<^sub>f\<^sub>f = Node\<^sub>f\<^sub>f 'a "'a tree\<^sub>f\<^sub>f list" |
74 |
datatype (*<*)(in early) (*>*)'a tree\<^sub>f\<^sub>i = Node\<^sub>f\<^sub>i 'a "'a tree\<^sub>f\<^sub>i llist" |
|
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
75 |
codatatype (*<*)(in early) (*>*)'a tree\<^sub>i\<^sub>f = Node\<^sub>i\<^sub>f 'a "'a tree\<^sub>i\<^sub>f list" |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
76 |
codatatype (*<*)(in early) (*>*)'a tree\<^sub>i\<^sub>i = Node\<^sub>i\<^sub>i 'a "'a tree\<^sub>i\<^sub>i llist" |
52792 | 77 |
|
62081 | 78 |
text \<open> |
54187 | 79 |
The first two tree types allow only paths of finite length, whereas the last two |
80 |
allow infinite paths. Orthogonally, the nodes in the first and third types have |
|
81 |
finitely many direct subtrees, whereas those of the second and fourth may have |
|
82 |
infinite branching. |
|
52840 | 83 |
|
69597 | 84 |
The package is part of \<^theory>\<open>Main\<close>. Additional functionality is provided by |
63680 | 85 |
the theory \<^file>\<open>~~/src/HOL/Library/BNF_Axiomatization.thy\<close>. |
55073 | 86 |
|
52805 | 87 |
The package, like its predecessor, fully adheres to the LCF philosophy |
76987 | 88 |
\<^cite>\<open>mgordon79\<close>: The characteristic theorems associated with the specified |
52805 | 89 |
(co)datatypes are derived rather than introduced axiomatically.% |
57542 | 90 |
\footnote{However, some of the |
58298 | 91 |
internal constructions and most of the internal proof obligations are omitted |
69505 | 92 |
if the \<open>quick_and_dirty\<close> option is enabled.} |
62756 | 93 |
The package is described in a number of scientific papers |
76987 | 94 |
\<^cite>\<open>"traytel-et-al-2012" and "blanchette-et-al-2014-impl" and |
95 |
"panny-et-al-2014" and "blanchette-et-al-2015-wit"\<close>. |
|
57542 | 96 |
The central notion is that of a \emph{bounded natural functor} (BNF)---a |
97 |
well-behaved type constructor for which nested (co)recursion is supported. |
|
52792 | 98 |
|
52794 | 99 |
This tutorial is organized as follows: |
100 |
||
52805 | 101 |
\begin{itemize} |
52822 | 102 |
\setlength{\itemsep}{0pt} |
103 |
||
52805 | 104 |
\item Section \ref{sec:defining-datatypes}, ``Defining Datatypes,'' |
58310 | 105 |
describes how to specify datatypes using the @{command datatype} command. |
52805 | 106 |
|
59861 | 107 |
\item Section \ref{sec:defining-primitively-recursive-functions}, ``Defining |
60192 | 108 |
Primitively Recursive Functions,'' describes how to specify functions |
76987 | 109 |
using @{command primrec}. (A separate tutorial \<^cite>\<open>"isabelle-function"\<close> |
62756 | 110 |
describes the more powerful \keyw{fun} and \keyw{function} commands.) |
52805 | 111 |
|
112 |
\item Section \ref{sec:defining-codatatypes}, ``Defining Codatatypes,'' |
|
53829 | 113 |
describes how to specify codatatypes using the @{command codatatype} command. |
52805 | 114 |
|
59861 | 115 |
\item Section \ref{sec:defining-primitively-corecursive-functions}, |
116 |
``Defining Primitively Corecursive Functions,'' describes how to specify |
|
60192 | 117 |
functions using the @{command primcorec} and |
62756 | 118 |
@{command primcorecursive} commands. (A separate tutorial |
76987 | 119 |
\<^cite>\<open>"isabelle-corec"\<close> describes the more powerful \keyw{corec} and |
62756 | 120 |
\keyw{corecursive} commands.) |
52794 | 121 |
|
59298 | 122 |
\item Section \ref{sec:registering-bounded-natural-functors}, ``Registering |
53552 | 123 |
Bounded Natural Functors,'' explains how to use the @{command bnf} command |
124 |
to register arbitrary type constructors as BNFs. |
|
52805 | 125 |
|
53552 | 126 |
\item Section |
71763
3b36fc4916af
removed LaTeX package and hack to avoid ALLCAPS headers
blanchet
parents:
71494
diff
changeset
|
127 |
\ref{sec:deriving-destructors-and-constructor-theorems}, |
3b36fc4916af
removed LaTeX package and hack to avoid ALLCAPS headers
blanchet
parents:
71494
diff
changeset
|
128 |
``Deriving Destructors and Constructor Theorems,'' explains how to |
55468
98b25c51e9e5
renamed 'wrap_free_constructors' to 'free_constructors' (cf. 'functor', 'bnf', etc.)
blanchet
parents:
55460
diff
changeset
|
129 |
use the command @{command free_constructors} to derive destructor constants |
58311 | 130 |
and theorems for freely generated types, as performed internally by |
131 |
@{command datatype} and @{command codatatype}. |
|
52794 | 132 |
|
58245 | 133 |
%\item Section \ref{sec:using-the-standard-ml-interface}, ``Using the Standard |
60192 | 134 |
%ML Interface,'' describes the package's programmatic interface. |
58245 | 135 |
|
59282 | 136 |
\item Section \ref{sec:selecting-plugins}, ``Selecting Plugins,'' is concerned |
137 |
with the package's interoperability with other Isabelle packages and tools, such |
|
138 |
as the code generator, Transfer, Lifting, and Quickcheck. |
|
52805 | 139 |
|
58395 | 140 |
\item Section \ref{sec:known-bugs-and-limitations}, ``Known Bugs and |
62756 | 141 |
Limitations,'' concludes with known open issues. |
52805 | 142 |
\end{itemize} |
52822 | 143 |
|
144 |
\newbox\boxA |
|
54185 | 145 |
\setbox\boxA=\hbox{\texttt{NOSPAM}} |
146 |
||
62756 | 147 |
\newcommand\authoremaili{\texttt{jasmin.blan{\color{white}NOSPAM}\kern-\wd\boxA{}chette@\allowbreak |
148 |
gmail.\allowbreak com}} |
|
52822 | 149 |
|
58305
57752a91eec4
renamed 'datatype' to 'old_datatype'; 'datatype' is now alias for 'datatype_new'
blanchet
parents:
58298
diff
changeset
|
150 |
Comments and bug reports concerning either the package or this tutorial should |
62756 | 151 |
be directed to the second author at \authoremaili{} or to the |
60146 | 152 |
\texttt{cl-isabelle-users} mailing list. |
62081 | 153 |
\<close> |
154 |
||
155 |
||
62731 | 156 |
section \<open>Defining Datatypes |
157 |
\label{sec:defining-datatypes}\<close> |
|
62081 | 158 |
|
159 |
text \<open> |
|
58310 | 160 |
Datatypes can be specified using the @{command datatype} command. |
62081 | 161 |
\<close> |
162 |
||
163 |
||
62731 | 164 |
subsection \<open>Introductory Examples |
165 |
\label{ssec:datatype-introductory-examples}\<close> |
|
62081 | 166 |
|
167 |
text \<open> |
|
53646 | 168 |
Datatypes are illustrated through concrete examples featuring different flavors |
169 |
of recursion. More examples can be found in the directory |
|
63680 | 170 |
\<^dir>\<open>~~/src/HOL/Datatype_Examples\<close>. |
62081 | 171 |
\<close> |
172 |
||
173 |
||
62731 | 174 |
subsubsection \<open>Nonrecursive Types |
175 |
\label{sssec:datatype-nonrecursive-types}\<close> |
|
62081 | 176 |
|
177 |
text \<open> |
|
53028 | 178 |
Datatypes are introduced by specifying the desired names and argument types for |
53491 | 179 |
their constructors. \emph{Enumeration} types are the simplest form of datatype. |
53028 | 180 |
All their constructors are nullary: |
62081 | 181 |
\<close> |
52805 | 182 |
|
58310 | 183 |
datatype trool = Truue | Faalse | Perhaaps |
52805 | 184 |
|
62081 | 185 |
text \<open> |
53028 | 186 |
\noindent |
69597 | 187 |
\<^const>\<open>Truue\<close>, \<^const>\<open>Faalse\<close>, and \<^const>\<open>Perhaaps\<close> have the type \<^typ>\<open>trool\<close>. |
53028 | 188 |
|
189 |
Polymorphic types are possible, such as the following option type, modeled after |
|
69597 | 190 |
its homologue from the \<^theory>\<open>HOL.Option\<close> theory: |
62081 | 191 |
\<close> |
52805 | 192 |
|
53025 | 193 |
(*<*) |
56995 | 194 |
hide_const None Some map_option |
54958
4933165fd112
do not use wrong constructor in auto-generated proof goal
panny
parents:
54955
diff
changeset
|
195 |
hide_type option |
53025 | 196 |
(*>*) |
58310 | 197 |
datatype 'a option = None | Some 'a |
52805 | 198 |
|
62081 | 199 |
text \<open> |
53028 | 200 |
\noindent |
69505 | 201 |
The constructors are \<open>None :: 'a option\<close> and |
202 |
\<open>Some :: 'a \<Rightarrow> 'a option\<close>. |
|
53028 | 203 |
|
204 |
The next example has three type parameters: |
|
62081 | 205 |
\<close> |
52805 | 206 |
|
58310 | 207 |
datatype ('a, 'b, 'c) triple = Triple 'a 'b 'c |
52805 | 208 |
|
62081 | 209 |
text \<open> |
53028 | 210 |
\noindent |
211 |
The constructor is |
|
69505 | 212 |
\<open>Triple :: 'a \<Rightarrow> 'b \<Rightarrow> 'c \<Rightarrow> ('a, 'b, 'c) triple\<close>. |
53028 | 213 |
Unlike in Standard ML, curried constructors are supported. The uncurried variant |
214 |
is also possible: |
|
62081 | 215 |
\<close> |
53028 | 216 |
|
58310 | 217 |
datatype ('a, 'b, 'c) triple\<^sub>u = Triple\<^sub>u "'a * 'b * 'c" |
53028 | 218 |
|
62081 | 219 |
text \<open> |
53863
c7364dca96f2
textual improvements following Christian Sternagel's feedback
blanchet
parents:
53857
diff
changeset
|
220 |
\noindent |
c7364dca96f2
textual improvements following Christian Sternagel's feedback
blanchet
parents:
53857
diff
changeset
|
221 |
Occurrences of nonatomic types on the right-hand side of the equal sign must be |
c7364dca96f2
textual improvements following Christian Sternagel's feedback
blanchet
parents:
53857
diff
changeset
|
222 |
enclosed in double quotes, as is customary in Isabelle. |
62081 | 223 |
\<close> |
224 |
||
225 |
||
62731 | 226 |
subsubsection \<open>Simple Recursion |
227 |
\label{sssec:datatype-simple-recursion}\<close> |
|
62081 | 228 |
|
229 |
text \<open> |
|
53491 | 230 |
Natural numbers are the simplest example of a recursive type: |
62081 | 231 |
\<close> |
52805 | 232 |
|
58310 | 233 |
datatype nat = Zero | Succ nat |
52805 | 234 |
|
62081 | 235 |
text \<open> |
53491 | 236 |
\noindent |
54187 | 237 |
Lists were shown in the introduction. Terminated lists are a variant that |
69597 | 238 |
stores a value of type \<^typ>\<open>'b\<close> at the very end: |
62081 | 239 |
\<close> |
52805 | 240 |
|
58310 | 241 |
datatype (*<*)(in early) (*>*)('a, 'b) tlist = TNil 'b | TCons 'a "('a, 'b) tlist" |
52805 | 242 |
|
52824 | 243 |
|
62731 | 244 |
subsubsection \<open>Mutual Recursion |
245 |
\label{sssec:datatype-mutual-recursion}\<close> |
|
62081 | 246 |
|
247 |
text \<open> |
|
53552 | 248 |
\emph{Mutually recursive} types are introduced simultaneously and may refer to |
249 |
each other. The example below introduces a pair of types for even and odd |
|
250 |
natural numbers: |
|
62081 | 251 |
\<close> |
52805 | 252 |
|
58310 | 253 |
datatype even_nat = Even_Zero | Even_Succ odd_nat |
58245 | 254 |
and odd_nat = Odd_Succ even_nat |
52805 | 255 |
|
62081 | 256 |
text \<open> |
53491 | 257 |
\noindent |
258 |
Arithmetic expressions are defined via terms, terms via factors, and factors via |
|
259 |
expressions: |
|
62081 | 260 |
\<close> |
52805 | 261 |
|
58310 | 262 |
datatype ('a, 'b) exp = |
52841 | 263 |
Term "('a, 'b) trm" | Sum "('a, 'b) trm" "('a, 'b) exp" |
52805 | 264 |
and ('a, 'b) trm = |
52841 | 265 |
Factor "('a, 'b) fct" | Prod "('a, 'b) fct" "('a, 'b) trm" |
266 |
and ('a, 'b) fct = |
|
267 |
Const 'a | Var 'b | Expr "('a, 'b) exp" |
|
52805 | 268 |
|
52824 | 269 |
|
62731 | 270 |
subsubsection \<open>Nested Recursion |
271 |
\label{sssec:datatype-nested-recursion}\<close> |
|
62081 | 272 |
|
273 |
text \<open> |
|
53491 | 274 |
\emph{Nested recursion} occurs when recursive occurrences of a type appear under |
275 |
a type constructor. The introduction showed some examples of trees with nesting |
|
69597 | 276 |
through lists. A more complex example, that reuses our \<^type>\<open>option\<close> type, |
53491 | 277 |
follows: |
62081 | 278 |
\<close> |
52805 | 279 |
|
58310 | 280 |
datatype 'a btree = |
53025 | 281 |
BNode 'a "'a btree option" "'a btree option" |
52805 | 282 |
|
62081 | 283 |
text \<open> |
53491 | 284 |
\noindent |
285 |
Not all nestings are admissible. For example, this command will fail: |
|
62081 | 286 |
\<close> |
52805 | 287 |
|
58310 | 288 |
datatype 'a wrong = W1 | W2 (*<*)'a |
53542 | 289 |
typ (*>*)"'a wrong \<Rightarrow> 'a" |
52806 | 290 |
|
62081 | 291 |
text \<open> |
53491 | 292 |
\noindent |
69505 | 293 |
The issue is that the function arrow \<open>\<Rightarrow>\<close> allows recursion |
53491 | 294 |
only through its right-hand side. This issue is inherited by polymorphic |
69505 | 295 |
datatypes defined in terms of~\<open>\<Rightarrow>\<close>: |
62081 | 296 |
\<close> |
53491 | 297 |
|
58310 | 298 |
datatype ('a, 'b) fun_copy = Fun "'a \<Rightarrow> 'b" |
299 |
datatype 'a also_wrong = W1 | W2 (*<*)'a |
|
55350 | 300 |
typ (*>*)"('a also_wrong, 'a) fun_copy" |
53491 | 301 |
|
62081 | 302 |
text \<open> |
53491 | 303 |
\noindent |
69597 | 304 |
The following definition of \<^typ>\<open>'a\<close>-branching trees is legal: |
62081 | 305 |
\<close> |
53621 | 306 |
|
58310 | 307 |
datatype 'a ftree = FTLeaf 'a | FTNode "'a \<Rightarrow> 'a ftree" |
53621 | 308 |
|
62081 | 309 |
text \<open> |
53621 | 310 |
\noindent |
55129
26bd1cba3ab5
killed 'More_BNFs' by moving its various bits where they (now) belong
blanchet
parents:
55114
diff
changeset
|
311 |
And so is the definition of hereditarily finite sets: |
62081 | 312 |
\<close> |
55129
26bd1cba3ab5
killed 'More_BNFs' by moving its various bits where they (now) belong
blanchet
parents:
55114
diff
changeset
|
313 |
|
58310 | 314 |
datatype hfset = HFSet "hfset fset" |
55129
26bd1cba3ab5
killed 'More_BNFs' by moving its various bits where they (now) belong
blanchet
parents:
55114
diff
changeset
|
315 |
|
62081 | 316 |
text \<open> |
55129
26bd1cba3ab5
killed 'More_BNFs' by moving its various bits where they (now) belong
blanchet
parents:
55114
diff
changeset
|
317 |
\noindent |
69505 | 318 |
In general, type constructors \<open>('a\<^sub>1, \<dots>, 'a\<^sub>m) t\<close> |
319 |
allow recursion on a subset of their type arguments \<open>'a\<^sub>1\<close>, \ldots, |
|
320 |
\<open>'a\<^sub>m\<close>. These type arguments are called \emph{live}; the remaining |
|
69597 | 321 |
type arguments are called \emph{dead}. In \<^typ>\<open>'a \<Rightarrow> 'b\<close> and |
322 |
\<^typ>\<open>('a, 'b) fun_copy\<close>, the type variable \<^typ>\<open>'a\<close> is dead and |
|
323 |
\<^typ>\<open>'b\<close> is live. |
|
53552 | 324 |
|
53647 | 325 |
Type constructors must be registered as BNFs to have live arguments. This is |
58311 | 326 |
done automatically for datatypes and codatatypes introduced by the |
327 |
@{command datatype} and @{command codatatype} commands. |
|
59298 | 328 |
Section~\ref{sec:registering-bounded-natural-functors} explains how to |
55351 | 329 |
register arbitrary type constructors as BNFs. |
54187 | 330 |
|
331 |
Here is another example that fails: |
|
62081 | 332 |
\<close> |
52806 | 333 |
|
58310 | 334 |
datatype 'a pow_list = PNil 'a (*<*)'a |
335 |
datatype 'a pow_list' = PNil' 'a (*>*)| PCons "('a * 'a) pow_list" |
|
54187 | 336 |
|
62081 | 337 |
text \<open> |
54187 | 338 |
\noindent |
55351 | 339 |
This attempted definition features a different flavor of nesting, where the |
340 |
recursive call in the type specification occurs around (rather than inside) |
|
341 |
another type constructor. |
|
62081 | 342 |
\<close> |
343 |
||
344 |
||
62731 | 345 |
subsubsection \<open>Auxiliary Constants |
346 |
\label{sssec:datatype-auxiliary-constants}\<close> |
|
62081 | 347 |
|
348 |
text \<open> |
|
58310 | 349 |
The @{command datatype} command introduces various constants in addition to |
53617 | 350 |
the constructors. With each datatype are associated set functions, a map |
62384 | 351 |
function, a predicator, a relator, discriminators, and selectors, all of which can be given |
69505 | 352 |
custom names. In the example below, the familiar names \<open>null\<close>, \<open>hd\<close>, |
353 |
\<open>tl\<close>, \<open>set\<close>, \<open>map\<close>, and \<open>list_all2\<close> override the |
|
354 |
default names \<open>is_Nil\<close>, \<open>un_Cons1\<close>, \<open>un_Cons2\<close>, |
|
355 |
\<open>set_list\<close>, \<open>map_list\<close>, and \<open>rel_list\<close>: |
|
62081 | 356 |
\<close> |
52822 | 357 |
|
52841 | 358 |
(*<*) |
359 |
no_translations |
|
360 |
"[x, xs]" == "x # [xs]" |
|
361 |
"[x]" == "x # []" |
|
362 |
||
363 |
no_notation |
|
364 |
Nil ("[]") and |
|
365 |
Cons (infixr "#" 65) |
|
366 |
||
53543 | 367 |
hide_type list |
62328 | 368 |
hide_const Nil Cons case_list hd tl set map list_all2 rec_list size_list list_all |
53025 | 369 |
|
59284 | 370 |
context early |
371 |
begin |
|
52841 | 372 |
(*>*) |
58310 | 373 |
datatype (set: 'a) list = |
57200
aab87ffa60cc
use 'where' clause for selector default value syntax
blanchet
parents:
57153
diff
changeset
|
374 |
null: Nil |
53025 | 375 |
| Cons (hd: 'a) (tl: "'a list") |
57206
d9be905d6283
changed syntax of map: and rel: arguments to BNF-based datatypes
blanchet
parents:
57200
diff
changeset
|
376 |
for |
d9be905d6283
changed syntax of map: and rel: arguments to BNF-based datatypes
blanchet
parents:
57200
diff
changeset
|
377 |
map: map |
d9be905d6283
changed syntax of map: and rel: arguments to BNF-based datatypes
blanchet
parents:
57200
diff
changeset
|
378 |
rel: list_all2 |
62328 | 379 |
pred: list_all |
57200
aab87ffa60cc
use 'where' clause for selector default value syntax
blanchet
parents:
57153
diff
changeset
|
380 |
where |
aab87ffa60cc
use 'where' clause for selector default value syntax
blanchet
parents:
57153
diff
changeset
|
381 |
"tl Nil = Nil" |
52822 | 382 |
|
62081 | 383 |
text \<open> |
52822 | 384 |
\noindent |
55353 | 385 |
The types of the constants that appear in the specification are listed below. |
55351 | 386 |
|
387 |
\medskip |
|
54187 | 388 |
|
389 |
\begin{tabular}{@ {}ll@ {}} |
|
390 |
Constructors: & |
|
69505 | 391 |
\<open>Nil :: 'a list\<close> \\ |
54187 | 392 |
& |
69505 | 393 |
\<open>Cons :: 'a \<Rightarrow> 'a list \<Rightarrow> 'a list\<close> \\ |
54187 | 394 |
Discriminator: & |
69505 | 395 |
\<open>null :: 'a list \<Rightarrow> bool\<close> \\ |
54187 | 396 |
Selectors: & |
69505 | 397 |
\<open>hd :: 'a list \<Rightarrow> 'a\<close> \\ |
54187 | 398 |
& |
69505 | 399 |
\<open>tl :: 'a list \<Rightarrow> 'a list\<close> \\ |
54187 | 400 |
Set function: & |
69505 | 401 |
\<open>set :: 'a list \<Rightarrow> 'a set\<close> \\ |
54187 | 402 |
Map function: & |
69505 | 403 |
\<open>map :: ('a \<Rightarrow> 'b) \<Rightarrow> 'a list \<Rightarrow> 'b list\<close> \\ |
54187 | 404 |
Relator: & |
69505 | 405 |
\<open>list_all2 :: ('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> 'a list \<Rightarrow> 'b list \<Rightarrow> bool\<close> |
54187 | 406 |
\end{tabular} |
407 |
||
55351 | 408 |
\medskip |
409 |
||
69597 | 410 |
The discriminator \<^const>\<open>null\<close> and the selectors \<^const>\<open>hd\<close> and \<^const>\<open>tl\<close> |
55351 | 411 |
are characterized by the following conditional equations: |
52822 | 412 |
% |
53025 | 413 |
\[@{thm list.collapse(1)[of xs, no_vars]} |
414 |
\qquad @{thm list.collapse(2)[of xs, no_vars]}\] |
|
52822 | 415 |
% |
54187 | 416 |
For two-constructor datatypes, a single discriminator constant is sufficient. |
69597 | 417 |
The discriminator associated with \<^const>\<open>Cons\<close> is simply |
418 |
\<^term>\<open>\<lambda>xs. \<not> null xs\<close>. |
|
52822 | 419 |
|
57200
aab87ffa60cc
use 'where' clause for selector default value syntax
blanchet
parents:
57153
diff
changeset
|
420 |
The \keyw{where} clause at the end of the command specifies a default value for |
aab87ffa60cc
use 'where' clause for selector default value syntax
blanchet
parents:
57153
diff
changeset
|
421 |
selectors applied to constructors on which they are not a priori specified. |
59282 | 422 |
In the example, it is used to ensure that the tail of the empty list is itself |
423 |
(instead of being left unspecified). |
|
52822 | 424 |
|
69597 | 425 |
Because \<^const>\<open>Nil\<close> is nullary, it is also possible to use |
426 |
\<^term>\<open>\<lambda>xs. xs = Nil\<close> as a discriminator. This is the default behavior |
|
427 |
if we omit the identifier \<^const>\<open>null\<close> and the associated colon. Some users |
|
57091 | 428 |
argue against this, because the mixture of constructors and selectors in the |
429 |
characteristic theorems can lead Isabelle's automation to switch between the |
|
430 |
constructor and the destructor view in surprising ways. |
|
52822 | 431 |
|
53863
c7364dca96f2
textual improvements following Christian Sternagel's feedback
blanchet
parents:
53857
diff
changeset
|
432 |
The usual mixfix syntax annotations are available for both types and |
c7364dca96f2
textual improvements following Christian Sternagel's feedback
blanchet
parents:
53857
diff
changeset
|
433 |
constructors. For example: |
62081 | 434 |
\<close> |
52794 | 435 |
|
53025 | 436 |
(*<*) |
437 |
end |
|
438 |
(*>*) |
|
58310 | 439 |
datatype ('a, 'b) prod (infixr "*" 20) = Pair 'a 'b |
53552 | 440 |
|
62731 | 441 |
text \<open>\blankline\<close> |
52822 | 442 |
|
58310 | 443 |
datatype (set: 'a) list = |
52822 | 444 |
null: Nil ("[]") |
52841 | 445 |
| Cons (hd: 'a) (tl: "'a list") (infixr "#" 65) |
57206
d9be905d6283
changed syntax of map: and rel: arguments to BNF-based datatypes
blanchet
parents:
57200
diff
changeset
|
446 |
for |
d9be905d6283
changed syntax of map: and rel: arguments to BNF-based datatypes
blanchet
parents:
57200
diff
changeset
|
447 |
map: map |
d9be905d6283
changed syntax of map: and rel: arguments to BNF-based datatypes
blanchet
parents:
57200
diff
changeset
|
448 |
rel: list_all2 |
62328 | 449 |
pred: list_all |
52841 | 450 |
|
62081 | 451 |
text \<open> |
53535 | 452 |
\noindent |
53863
c7364dca96f2
textual improvements following Christian Sternagel's feedback
blanchet
parents:
53857
diff
changeset
|
453 |
Incidentally, this is how the traditional syntax can be set up: |
62081 | 454 |
\<close> |
52841 | 455 |
|
456 |
syntax "_list" :: "args \<Rightarrow> 'a list" ("[(_)]") |
|
457 |
||
62731 | 458 |
text \<open>\blankline\<close> |
53552 | 459 |
|
52841 | 460 |
translations |
461 |
"[x, xs]" == "x # [xs]" |
|
462 |
"[x]" == "x # []" |
|
52822 | 463 |
|
52824 | 464 |
|
62731 | 465 |
subsection \<open>Command Syntax |
466 |
\label{ssec:datatype-command-syntax}\<close> |
|
467 |
||
468 |
subsubsection \<open>\keyw{datatype} |
|
62740 | 469 |
\label{sssec:datatype}\<close> |
62081 | 470 |
|
471 |
text \<open> |
|
53829 | 472 |
\begin{matharray}{rcl} |
69505 | 473 |
@{command_def "datatype"} & : & \<open>local_theory \<rightarrow> local_theory\<close> |
53829 | 474 |
\end{matharray} |
52822 | 475 |
|
69597 | 476 |
\<^rail>\<open> |
59282 | 477 |
@@{command datatype} target? @{syntax dt_options}? @{syntax dt_spec} |
52828 | 478 |
; |
59280 | 479 |
@{syntax_def dt_options}: '(' ((@{syntax plugins} | 'discs_sels') + ',') ')' |
58190 | 480 |
; |
59280 | 481 |
@{syntax_def plugins}: 'plugins' ('only' | 'del') ':' (name +) |
57206
d9be905d6283
changed syntax of map: and rel: arguments to BNF-based datatypes
blanchet
parents:
57200
diff
changeset
|
482 |
; |
59282 | 483 |
@{syntax_def dt_spec}: (@{syntax dt_name} '=' (@{syntax dt_ctor} + '|') \<newline> |
64939 | 484 |
@{syntax map_rel_pred}? (@'where' (prop + '|'))? + @'and') |
59282 | 485 |
; |
64939 | 486 |
@{syntax_def map_rel_pred}: @'for' ((('map' | 'rel' | 'pred') ':' name) +) |
69597 | 487 |
\<close> |
52824 | 488 |
|
55351 | 489 |
\medskip |
490 |
||
491 |
\noindent |
|
58310 | 492 |
The @{command datatype} command introduces a set of mutually recursive |
55460
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
493 |
datatypes specified by their constructors. |
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
494 |
|
53863
c7364dca96f2
textual improvements following Christian Sternagel's feedback
blanchet
parents:
53857
diff
changeset
|
495 |
The syntactic entity \synt{target} can be used to specify a local |
76987 | 496 |
context (e.g., \<open>(in linorder)\<close> \<^cite>\<open>"isabelle-isar-ref"\<close>), |
57200
aab87ffa60cc
use 'where' clause for selector default value syntax
blanchet
parents:
57153
diff
changeset
|
497 |
and \synt{prop} denotes a HOL proposition. |
55460
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
498 |
|
58190 | 499 |
The optional target is optionally followed by a combination of the following |
56124 | 500 |
options: |
52822 | 501 |
|
52824 | 502 |
\begin{itemize} |
503 |
\setlength{\itemsep}{0pt} |
|
504 |
||
505 |
\item |
|
69505 | 506 |
The \<open>plugins\<close> option indicates which plugins should be enabled |
507 |
(\<open>only\<close>) or disabled (\<open>del\<close>). By default, all plugins are enabled. |
|
58190 | 508 |
|
509 |
\item |
|
69505 | 510 |
The \<open>discs_sels\<close> option indicates that discriminators and selectors |
57094
589ec121ce1a
don't generate discriminators and selectors for 'datatype_new' unless the user asked for it
blanchet
parents:
57092
diff
changeset
|
511 |
should be generated. The option is implicitly enabled if names are specified for |
589ec121ce1a
don't generate discriminators and selectors for 'datatype_new' unless the user asked for it
blanchet
parents:
57092
diff
changeset
|
512 |
discriminators or selectors. |
52824 | 513 |
\end{itemize} |
52822 | 514 |
|
57200
aab87ffa60cc
use 'where' clause for selector default value syntax
blanchet
parents:
57153
diff
changeset
|
515 |
The optional \keyw{where} clause specifies default values for selectors. |
aab87ffa60cc
use 'where' clause for selector default value syntax
blanchet
parents:
57153
diff
changeset
|
516 |
Each proposition must be an equation of the form |
69505 | 517 |
\<open>un_D (C \<dots>) = \<dots>\<close>, where \<open>C\<close> is a constructor and |
518 |
\<open>un_D\<close> is a selector. |
|
57200
aab87ffa60cc
use 'where' clause for selector default value syntax
blanchet
parents:
57153
diff
changeset
|
519 |
|
52827 | 520 |
The left-hand sides of the datatype equations specify the name of the type to |
53534 | 521 |
define, its type parameters, and additional information: |
52822 | 522 |
|
69597 | 523 |
\<^rail>\<open> |
57206
d9be905d6283
changed syntax of map: and rel: arguments to BNF-based datatypes
blanchet
parents:
57200
diff
changeset
|
524 |
@{syntax_def dt_name}: @{syntax tyargs}? name mixfix? |
52824 | 525 |
; |
57092 | 526 |
@{syntax_def tyargs}: typefree | '(' (('dead' | name ':')? typefree + ',') ')' |
69597 | 527 |
\<close> |
52822 | 528 |
|
55351 | 529 |
\medskip |
530 |
||
52827 | 531 |
\noindent |
55474 | 532 |
The syntactic entity \synt{name} denotes an identifier, \synt{mixfix} denotes |
533 |
the usual parenthesized mixfix notation, and \synt{typefree} denotes fixed type |
|
76987 | 534 |
variable (\<^typ>\<open>'a\<close>, \<^typ>\<open>'b\<close>, \ldots) \<^cite>\<open>"isabelle-isar-ref"\<close>. |
52822 | 535 |
|
52827 | 536 |
The optional names preceding the type variables allow to override the default |
69505 | 537 |
names of the set functions (\<open>set\<^sub>1_t\<close>, \ldots, \<open>set\<^sub>m_t\<close>). Type |
538 |
arguments can be marked as dead by entering \<open>dead\<close> in front of the |
|
539 |
type variable (e.g., \<open>(dead 'a)\<close>); otherwise, they are live or dead |
|
55705 | 540 |
(and a set function is generated or not) depending on where they occur in the |
541 |
right-hand sides of the definition. Declaring a type argument as dead can speed |
|
542 |
up the type definition but will prevent any later (co)recursion through that |
|
543 |
type argument. |
|
544 |
||
53647 | 545 |
Inside a mutually recursive specification, all defined datatypes must |
546 |
mention exactly the same type variables in the same order. |
|
52822 | 547 |
|
69597 | 548 |
\<^rail>\<open> |
57200
aab87ffa60cc
use 'where' clause for selector default value syntax
blanchet
parents:
57153
diff
changeset
|
549 |
@{syntax_def dt_ctor}: (name ':')? name (@{syntax dt_ctor_arg} * ) mixfix? |
69597 | 550 |
\<close> |
52824 | 551 |
|
53535 | 552 |
\medskip |
553 |
||
52827 | 554 |
\noindent |
53863
c7364dca96f2
textual improvements following Christian Sternagel's feedback
blanchet
parents:
53857
diff
changeset
|
555 |
The main constituents of a constructor specification are the name of the |
52827 | 556 |
constructor and the list of its argument types. An optional discriminator name |
59722 | 557 |
can be supplied at the front. If discriminators are enabled (cf.\ the |
69505 | 558 |
\<open>discs_sels\<close> option) but no name is supplied, the default is |
559 |
\<open>\<lambda>x. x = C\<^sub>j\<close> for nullary constructors and |
|
560 |
\<open>t.is_C\<^sub>j\<close> otherwise. |
|
52822 | 561 |
|
69597 | 562 |
\<^rail>\<open> |
55472
990651bfc65b
updated docs to reflect the new 'free_constructors' syntax
blanchet
parents:
55468
diff
changeset
|
563 |
@{syntax_def dt_ctor_arg}: type | '(' name ':' type ')' |
69597 | 564 |
\<close> |
52827 | 565 |
|
53535 | 566 |
\medskip |
567 |
||
52827 | 568 |
\noindent |
76987 | 569 |
The syntactic entity \synt{type} denotes a HOL type \<^cite>\<open>"isabelle-isar-ref"\<close>. |
55474 | 570 |
|
52827 | 571 |
In addition to the type of a constructor argument, it is possible to specify a |
59722 | 572 |
name for the corresponding selector. The same selector name can be reused for |
573 |
arguments to several constructors as long as the arguments share the same type. |
|
69505 | 574 |
If selectors are enabled (cf.\ the \<open>discs_sels\<close> option) but no name is |
575 |
supplied, the default name is \<open>un_C\<^sub>ji\<close>. |
|
62081 | 576 |
\<close> |
577 |
||
578 |
||
62731 | 579 |
subsubsection \<open>\keyw{datatype_compat} |
580 |
\label{sssec:datatype-compat}\<close> |
|
62081 | 581 |
|
582 |
text \<open> |
|
53829 | 583 |
\begin{matharray}{rcl} |
69505 | 584 |
@{command_def "datatype_compat"} & : & \<open>local_theory \<rightarrow> local_theory\<close> |
53829 | 585 |
\end{matharray} |
586 |
||
69597 | 587 |
\<^rail>\<open> |
55531
601ca8efa000
renamed 'datatype_new_compat' to 'datatype_compat'
blanchet
parents:
55530
diff
changeset
|
588 |
@@{command datatype_compat} (name +) |
69597 | 589 |
\<close> |
53829 | 590 |
|
55351 | 591 |
\medskip |
592 |
||
53829 | 593 |
\noindent |
55531
601ca8efa000
renamed 'datatype_new_compat' to 'datatype_compat'
blanchet
parents:
55530
diff
changeset
|
594 |
The @{command datatype_compat} command registers new-style datatypes as |
58245 | 595 |
old-style datatypes and invokes the old-style plugins. For example: |
62081 | 596 |
\<close> |
53621 | 597 |
|
55531
601ca8efa000
renamed 'datatype_new_compat' to 'datatype_compat'
blanchet
parents:
55530
diff
changeset
|
598 |
datatype_compat even_nat odd_nat |
53621 | 599 |
|
62731 | 600 |
text \<open>\blankline\<close> |
601 |
||
69597 | 602 |
ML \<open>Old_Datatype_Data.get_info \<^theory> \<^type_name>\<open>even_nat\<close>\<close> |
62081 | 603 |
|
604 |
text \<open> |
|
76987 | 605 |
The syntactic entity \synt{name} denotes an identifier \<^cite>\<open>"isabelle-isar-ref"\<close>. |
55474 | 606 |
|
60135
852f7a49ec0c
updated docs, esp. relating to 'datatype_compat'
blanchet
parents:
60134
diff
changeset
|
607 |
The command is sometimes useful when migrating from the old datatype package to |
852f7a49ec0c
updated docs, esp. relating to 'datatype_compat'
blanchet
parents:
60134
diff
changeset
|
608 |
the new one. |
55474 | 609 |
|
610 |
A few remarks concern nested recursive datatypes: |
|
53748 | 611 |
|
612 |
\begin{itemize} |
|
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
613 |
\setlength{\itemsep}{0pt} |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
614 |
|
55871 | 615 |
\item The old-style, nested-as-mutual induction rule and recursor theorems are |
69505 | 616 |
generated under their usual names but with ``\<open>compat_\<close>'' prefixed |
617 |
(e.g., \<open>compat_tree.induct\<close>, \<open>compat_tree.inducts\<close>, and |
|
618 |
\<open>compat_tree.rec\<close>). These theorems should be identical to the ones |
|
61351 | 619 |
generated by the old datatype package, \emph{up to the order of the |
69505 | 620 |
premises}---meaning that the subgoals generated by the \<open>induct\<close> or |
621 |
\<open>induction\<close> method may be in a different order than before. |
|
53748 | 622 |
|
623 |
\item All types through which recursion takes place must be new-style datatypes |
|
59722 | 624 |
or the function type. |
53748 | 625 |
\end{itemize} |
62081 | 626 |
\<close> |
627 |
||
628 |
||
62731 | 629 |
subsection \<open>Generated Constants |
630 |
\label{ssec:datatype-generated-constants}\<close> |
|
62081 | 631 |
|
632 |
text \<open> |
|
69505 | 633 |
Given a datatype \<open>('a\<^sub>1, \<dots>, 'a\<^sub>m) t\<close> with $m$ live type variables |
634 |
and $n$ constructors \<open>t.C\<^sub>1\<close>, \ldots, \<open>t.C\<^sub>n\<close>, the following |
|
59284 | 635 |
auxiliary constants are introduced: |
53617 | 636 |
|
55353 | 637 |
\medskip |
638 |
||
639 |
\begin{tabular}{@ {}ll@ {}} |
|
640 |
Case combinator: & |
|
69505 | 641 |
\<open>t.case_t\<close> (rendered using the familiar \<open>case\<close>--\<open>of\<close> syntax) \\ |
55353 | 642 |
Discriminators: & |
69505 | 643 |
\<open>t.is_C\<^sub>1\<close>$, \ldots, $\<open>t.is_C\<^sub>n\<close> \\ |
55353 | 644 |
Selectors: & |
69505 | 645 |
\<open>t.un_C\<^sub>11\<close>$, \ldots, $\<open>t.un_C\<^sub>1k\<^sub>1\<close> \\ |
55353 | 646 |
& \quad\vdots \\ |
69505 | 647 |
& \<open>t.un_C\<^sub>n1\<close>$, \ldots, $\<open>t.un_C\<^sub>nk\<^sub>n\<close> \\ |
55353 | 648 |
Set functions: & |
69505 | 649 |
\<open>t.set\<^sub>1_t\<close>, \ldots, \<open>t.set\<^sub>m_t\<close> \\ |
55353 | 650 |
Map function: & |
69505 | 651 |
\<open>t.map_t\<close> \\ |
55353 | 652 |
Relator: & |
69505 | 653 |
\<open>t.rel_t\<close> \\ |
55353 | 654 |
Recursor: & |
69505 | 655 |
\<open>t.rec_t\<close> |
55353 | 656 |
\end{tabular} |
657 |
||
658 |
\medskip |
|
53617 | 659 |
|
660 |
\noindent |
|
69505 | 661 |
The discriminators and selectors are generated only if the \<open>discs_sels\<close> |
59722 | 662 |
option is enabled or if names are specified for discriminators or selectors. |
62330 | 663 |
The set functions, map function, predicator, and relator are generated only if $m > 0$. |
59722 | 664 |
|
58245 | 665 |
In addition, some of the plugins introduce their own constants |
59282 | 666 |
(Section~\ref{sec:selecting-plugins}). The case combinator, discriminators, |
58508 | 667 |
and selectors are collectively called \emph{destructors}. The prefix |
69505 | 668 |
``\<open>t.\<close>'' is an optional component of the names and is normally hidden. |
62081 | 669 |
\<close> |
670 |
||
671 |
||
62731 | 672 |
subsection \<open>Generated Theorems |
673 |
\label{ssec:datatype-generated-theorems}\<close> |
|
62081 | 674 |
|
675 |
text \<open> |
|
58310 | 676 |
The characteristic theorems generated by @{command datatype} are grouped in |
53623 | 677 |
three broad categories: |
53535 | 678 |
|
53543 | 679 |
\begin{itemize} |
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
680 |
\setlength{\itemsep}{0pt} |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
681 |
|
56655 | 682 |
\item The \emph{free constructor theorems} |
683 |
(Section~\ref{sssec:free-constructor-theorems}) are properties of the |
|
684 |
constructors and destructors that can be derived for any freely generated type. |
|
685 |
Internally, the derivation is performed by @{command free_constructors}. |
|
686 |
||
687 |
\item The \emph{functorial theorems} (Section~\ref{sssec:functorial-theorems}) |
|
688 |
are properties of datatypes related to their BNF nature. |
|
689 |
||
690 |
\item The \emph{inductive theorems} (Section~\ref{sssec:inductive-theorems}) |
|
691 |
are properties of datatypes related to their inductive nature. |
|
53552 | 692 |
|
53543 | 693 |
\end{itemize} |
53535 | 694 |
|
695 |
\noindent |
|
62756 | 696 |
The full list of named theorems can be obtained by issuing the command |
697 |
\keyw{print_theorems} immediately after the datatype definition. This list |
|
698 |
includes theorems produced by plugins (Section~\ref{sec:selecting-plugins}), |
|
699 |
but normally excludes low-level theorems that reveal internal constructions. |
|
700 |
To make these accessible, add the line |
|
62081 | 701 |
\<close> |
53535 | 702 |
|
62093 | 703 |
declare [[bnf_internals]] |
53542 | 704 |
(*<*) |
62093 | 705 |
declare [[bnf_internals = false]] |
53542 | 706 |
(*>*) |
53535 | 707 |
|
62081 | 708 |
|
62731 | 709 |
subsubsection \<open>Free Constructor Theorems |
710 |
\label{sssec:free-constructor-theorems}\<close> |
|
53535 | 711 |
|
53543 | 712 |
(*<*) |
53837 | 713 |
consts nonnull :: 'a |
53543 | 714 |
(*>*) |
715 |
||
62081 | 716 |
text \<open> |
54621 | 717 |
The free constructor theorems are partitioned in three subgroups. The first |
718 |
subgroup of properties is concerned with the constructors. They are listed below |
|
69597 | 719 |
for \<^typ>\<open>'a list\<close>: |
53543 | 720 |
|
53552 | 721 |
\begin{indentblock} |
53543 | 722 |
\begin{description} |
53544 | 723 |
|
69505 | 724 |
\item[\<open>t.\<close>\hthm{inject} \<open>[iff, induct_simp]\<close>\rm:] ~ \\ |
53544 | 725 |
@{thm list.inject[no_vars]} |
726 |
||
69505 | 727 |
\item[\<open>t.\<close>\hthm{distinct} \<open>[simp, induct_simp]\<close>\rm:] ~ \\ |
53543 | 728 |
@{thm list.distinct(1)[no_vars]} \\ |
729 |
@{thm list.distinct(2)[no_vars]} |
|
730 |
||
69505 | 731 |
\item[\<open>t.\<close>\hthm{exhaust} \<open>[cases t, case_names C\<^sub>1 \<dots> C\<^sub>n]\<close>\rm:] ~ \\ |
53543 | 732 |
@{thm list.exhaust[no_vars]} |
733 |
||
69505 | 734 |
\item[\<open>t.\<close>\hthm{nchotomy}\rm:] ~ \\ |
53543 | 735 |
@{thm list.nchotomy[no_vars]} |
736 |
||
737 |
\end{description} |
|
53552 | 738 |
\end{indentblock} |
53543 | 739 |
|
740 |
\noindent |
|
53621 | 741 |
In addition, these nameless theorems are registered as safe elimination rules: |
742 |
||
743 |
\begin{indentblock} |
|
744 |
\begin{description} |
|
745 |
||
69505 | 746 |
\item[\<open>t.\<close>\hthm{distinct {\upshape[}THEN notE}\<open>, elim!\<close>\hthm{\upshape]}\rm:] ~ \\ |
53621 | 747 |
@{thm list.distinct(1)[THEN notE, elim!, no_vars]} \\ |
748 |
@{thm list.distinct(2)[THEN notE, elim!, no_vars]} |
|
749 |
||
750 |
\end{description} |
|
751 |
\end{indentblock} |
|
752 |
||
753 |
\noindent |
|
53543 | 754 |
The next subgroup is concerned with the case combinator: |
755 |
||
53552 | 756 |
\begin{indentblock} |
53543 | 757 |
\begin{description} |
53544 | 758 |
|
69505 | 759 |
\item[\<open>t.\<close>\hthm{case} \<open>[simp, code]\<close>\rm:] ~ \\ |
53543 | 760 |
@{thm list.case(1)[no_vars]} \\ |
58335
a5a3b576fcfb
generate 'code' attribute only if 'code' plugin is enabled
blanchet
parents:
58311
diff
changeset
|
761 |
@{thm list.case(2)[no_vars]} \\ |
69505 | 762 |
The \<open>[code]\<close> attribute is set by the \<open>code\<close> plugin |
59284 | 763 |
(Section~\ref{ssec:code-generator}). |
53543 | 764 |
|
69505 | 765 |
\item[\<open>t.\<close>\hthm{case_cong} \<open>[fundef_cong]\<close>\rm:] ~ \\ |
53543 | 766 |
@{thm list.case_cong[no_vars]} |
767 |
||
69505 | 768 |
\item[\<open>t.\<close>\hthm{case_cong_weak} \<open>[cong]\<close>\rm:] ~ \\ |
57983
6edc3529bb4e
reordered some (co)datatype property names for more consistency
blanchet
parents:
57982
diff
changeset
|
769 |
@{thm list.case_cong_weak[no_vars]} |
53543 | 770 |
|
69505 | 771 |
\item[\<open>t.\<close>\hthm{case_distrib}\rm:] ~ \\ |
59268 | 772 |
@{thm list.case_distrib[no_vars]} |
773 |
||
69505 | 774 |
\item[\<open>t.\<close>\hthm{split}\rm:] ~ \\ |
53543 | 775 |
@{thm list.split[no_vars]} |
776 |
||
69505 | 777 |
\item[\<open>t.\<close>\hthm{split_asm}\rm:] ~ \\ |
53543 | 778 |
@{thm list.split_asm[no_vars]} |
779 |
||
69505 | 780 |
\item[\<open>t.\<close>\hthm{splits} = \<open>split split_asm\<close>] |
53543 | 781 |
|
782 |
\end{description} |
|
53552 | 783 |
\end{indentblock} |
53543 | 784 |
|
785 |
\noindent |
|
54621 | 786 |
The third subgroup revolves around discriminators and selectors: |
53543 | 787 |
|
53552 | 788 |
\begin{indentblock} |
53543 | 789 |
\begin{description} |
53544 | 790 |
|
69505 | 791 |
\item[\<open>t.\<close>\hthm{disc} \<open>[simp]\<close>\rm:] ~ \\ |
53694 | 792 |
@{thm list.disc(1)[no_vars]} \\ |
793 |
@{thm list.disc(2)[no_vars]} |
|
794 |
||
69505 | 795 |
\item[\<open>t.\<close>\hthm{discI}\rm:] ~ \\ |
53703 | 796 |
@{thm list.discI(1)[no_vars]} \\ |
797 |
@{thm list.discI(2)[no_vars]} |
|
798 |
||
69505 | 799 |
\item[\<open>t.\<close>\hthm{sel} \<open>[simp, code]\<close>\rm:] ~ \\ |
53694 | 800 |
@{thm list.sel(1)[no_vars]} \\ |
58335
a5a3b576fcfb
generate 'code' attribute only if 'code' plugin is enabled
blanchet
parents:
58311
diff
changeset
|
801 |
@{thm list.sel(2)[no_vars]} \\ |
69505 | 802 |
The \<open>[code]\<close> attribute is set by the \<open>code\<close> plugin |
59284 | 803 |
(Section~\ref{ssec:code-generator}). |
53543 | 804 |
|
69505 | 805 |
\item[\<open>t.\<close>\hthm{collapse} \<open>[simp]\<close>\rm:] ~ \\ |
53543 | 806 |
@{thm list.collapse(1)[no_vars]} \\ |
58151
414deb2ef328
take out 'x = C' of the simplifier for unit types
blanchet
parents:
58121
diff
changeset
|
807 |
@{thm list.collapse(2)[no_vars]} \\ |
69505 | 808 |
The \<open>[simp]\<close> attribute is exceptionally omitted for datatypes equipped |
58151
414deb2ef328
take out 'x = C' of the simplifier for unit types
blanchet
parents:
58121
diff
changeset
|
809 |
with a single nullary constructor, because a property of the form |
69597 | 810 |
\<^prop>\<open>x = C\<close> is not suitable as a simplification rule. |
53543 | 811 |
|
69505 | 812 |
\item[\<open>t.\<close>\hthm{distinct_disc} \<open>[dest]\<close>\rm:] ~ \\ |
69597 | 813 |
These properties are missing for \<^typ>\<open>'a list\<close> because there is only one |
59284 | 814 |
proper discriminator. If the datatype had been introduced with a second |
69597 | 815 |
discriminator called \<^const>\<open>nonnull\<close>, they would have read as follows: \\[\jot] |
816 |
\<^prop>\<open>null list \<Longrightarrow> \<not> nonnull list\<close> \\ |
|
817 |
\<^prop>\<open>nonnull list \<Longrightarrow> \<not> null list\<close> |
|
53543 | 818 |
|
69505 | 819 |
\item[\<open>t.\<close>\hthm{exhaust_disc} \<open>[case_names C\<^sub>1 \<dots> C\<^sub>n]\<close>\rm:] ~ \\ |
57983
6edc3529bb4e
reordered some (co)datatype property names for more consistency
blanchet
parents:
57982
diff
changeset
|
820 |
@{thm list.exhaust_disc[no_vars]} |
6edc3529bb4e
reordered some (co)datatype property names for more consistency
blanchet
parents:
57982
diff
changeset
|
821 |
|
69505 | 822 |
\item[\<open>t.\<close>\hthm{exhaust_sel} \<open>[case_names C\<^sub>1 \<dots> C\<^sub>n]\<close>\rm:] ~ \\ |
57983
6edc3529bb4e
reordered some (co)datatype property names for more consistency
blanchet
parents:
57982
diff
changeset
|
823 |
@{thm list.exhaust_sel[no_vars]} |
53916 | 824 |
|
69505 | 825 |
\item[\<open>t.\<close>\hthm{expand}\rm:] ~ \\ |
53543 | 826 |
@{thm list.expand[no_vars]} |
827 |
||
69505 | 828 |
\item[\<open>t.\<close>\hthm{split_sel}\rm:] ~ \\ |
57983
6edc3529bb4e
reordered some (co)datatype property names for more consistency
blanchet
parents:
57982
diff
changeset
|
829 |
@{thm list.split_sel[no_vars]} |
6edc3529bb4e
reordered some (co)datatype property names for more consistency
blanchet
parents:
57982
diff
changeset
|
830 |
|
69505 | 831 |
\item[\<open>t.\<close>\hthm{split_sel_asm}\rm:] ~ \\ |
57983
6edc3529bb4e
reordered some (co)datatype property names for more consistency
blanchet
parents:
57982
diff
changeset
|
832 |
@{thm list.split_sel_asm[no_vars]} |
53917 | 833 |
|
69505 | 834 |
\item[\<open>t.\<close>\hthm{split_sels} = \<open>split_sel split_sel_asm\<close>] |
835 |
||
836 |
\item[\<open>t.\<close>\hthm{case_eq_if}\rm:] ~ \\ |
|
54491 | 837 |
@{thm list.case_eq_if[no_vars]} |
53543 | 838 |
|
69505 | 839 |
\item[\<open>t.\<close>\hthm{disc_eq_case}\rm:] ~ \\ |
59273 | 840 |
@{thm list.disc_eq_case(1)[no_vars]} \\ |
841 |
@{thm list.disc_eq_case(2)[no_vars]} |
|
842 |
||
53543 | 843 |
\end{description} |
53552 | 844 |
\end{indentblock} |
54152 | 845 |
|
846 |
\noindent |
|
69505 | 847 |
In addition, equational versions of \<open>t.disc\<close> are registered with the |
848 |
\<open>[code]\<close> attribute. The \<open>[code]\<close> attribute is set by the |
|
849 |
\<open>code\<close> plugin (Section~\ref{ssec:code-generator}). |
|
62081 | 850 |
\<close> |
851 |
||
852 |
||
62731 | 853 |
subsubsection \<open>Functorial Theorems |
854 |
\label{sssec:functorial-theorems}\<close> |
|
62081 | 855 |
|
856 |
text \<open> |
|
61349 | 857 |
The functorial theorems are generated for type constructors with at least |
69597 | 858 |
one live type argument (e.g., \<^typ>\<open>'a list\<close>). They are partitioned in two |
61349 | 859 |
subgroups. The first subgroup consists of properties involving the |
860 |
constructors or the destructors and either a set function, the map function, |
|
62330 | 861 |
the predicator, or the relator: |
53552 | 862 |
|
863 |
\begin{indentblock} |
|
864 |
\begin{description} |
|
865 |
||
69505 | 866 |
\item[\<open>t.\<close>\hthm{case_transfer} \<open>[transfer_rule]\<close>\rm:] ~ \\ |
58915 | 867 |
@{thm list.case_transfer[no_vars]} \\ |
69505 | 868 |
This property is generated by the \<open>transfer\<close> plugin |
61349 | 869 |
(Section~\ref{ssec:transfer}). |
69505 | 870 |
%The \<open>[transfer_rule]\<close> attribute is set by the \<open>transfer\<close> plugin |
61350 | 871 |
%(Section~\ref{ssec:transfer}). |
58915 | 872 |
|
69505 | 873 |
\item[\<open>t.\<close>\hthm{sel_transfer} \<open>[transfer_rule]\<close>\rm:] ~ \\ |
69597 | 874 |
This property is missing for \<^typ>\<open>'a list\<close> because there is no common |
58915 | 875 |
selector to all constructors. \\ |
69505 | 876 |
The \<open>[transfer_rule]\<close> attribute is set by the \<open>transfer\<close> plugin |
61349 | 877 |
(Section~\ref{ssec:transfer}). |
58915 | 878 |
|
69505 | 879 |
\item[\<open>t.\<close>\hthm{ctr_transfer} \<open>[transfer_rule]\<close>\rm:] ~ \\ |
58000 | 880 |
@{thm list.ctr_transfer(1)[no_vars]} \\ |
58915 | 881 |
@{thm list.ctr_transfer(2)[no_vars]} \\ |
69505 | 882 |
The \<open>[transfer_rule]\<close> attribute is set by the \<open>transfer\<close> plugin |
61349 | 883 |
(Section~\ref{ssec:transfer}) . |
58915 | 884 |
|
69505 | 885 |
\item[\<open>t.\<close>\hthm{disc_transfer} \<open>[transfer_rule]\<close>\rm:] ~ \\ |
58096 | 886 |
@{thm list.disc_transfer(1)[no_vars]} \\ |
58915 | 887 |
@{thm list.disc_transfer(2)[no_vars]} \\ |
69505 | 888 |
The \<open>[transfer_rule]\<close> attribute is set by the \<open>transfer\<close> plugin |
61349 | 889 |
(Section~\ref{ssec:transfer}). |
58096 | 890 |
|
69505 | 891 |
\item[\<open>t.\<close>\hthm{set} \<open>[simp, code]\<close>\rm:] ~ \\ |
53694 | 892 |
@{thm list.set(1)[no_vars]} \\ |
58335
a5a3b576fcfb
generate 'code' attribute only if 'code' plugin is enabled
blanchet
parents:
58311
diff
changeset
|
893 |
@{thm list.set(2)[no_vars]} \\ |
69505 | 894 |
The \<open>[code]\<close> attribute is set by the \<open>code\<close> plugin |
59284 | 895 |
(Section~\ref{ssec:code-generator}). |
53552 | 896 |
|
69505 | 897 |
\item[\<open>t.\<close>\hthm{set_cases} \<open>[consumes 1, cases set: set\<^sub>i_t]\<close>\rm:] ~ \\ |
57894 | 898 |
@{thm list.set_cases[no_vars]} |
899 |
||
69505 | 900 |
\item[\<open>t.\<close>\hthm{set_intros}\rm:] ~ \\ |
57892 | 901 |
@{thm list.set_intros(1)[no_vars]} \\ |
902 |
@{thm list.set_intros(2)[no_vars]} |
|
903 |
||
69505 | 904 |
\item[\<open>t.\<close>\hthm{set_sel}\rm:] ~ \\ |
57983
6edc3529bb4e
reordered some (co)datatype property names for more consistency
blanchet
parents:
57982
diff
changeset
|
905 |
@{thm list.set_sel[no_vars]} |
57153 | 906 |
|
69505 | 907 |
\item[\<open>t.\<close>\hthm{map} \<open>[simp, code]\<close>\rm:] ~ \\ |
53552 | 908 |
@{thm list.map(1)[no_vars]} \\ |
58335
a5a3b576fcfb
generate 'code' attribute only if 'code' plugin is enabled
blanchet
parents:
58311
diff
changeset
|
909 |
@{thm list.map(2)[no_vars]} \\ |
69505 | 910 |
The \<open>[code]\<close> attribute is set by the \<open>code\<close> plugin |
59284 | 911 |
(Section~\ref{ssec:code-generator}). |
53552 | 912 |
|
69505 | 913 |
\item[\<open>t.\<close>\hthm{map_disc_iff} \<open>[simp]\<close>\rm:] ~ \\ |
57983
6edc3529bb4e
reordered some (co)datatype property names for more consistency
blanchet
parents:
57982
diff
changeset
|
914 |
@{thm list.map_disc_iff[no_vars]} |
6edc3529bb4e
reordered some (co)datatype property names for more consistency
blanchet
parents:
57982
diff
changeset
|
915 |
|
69505 | 916 |
\item[\<open>t.\<close>\hthm{map_sel}\rm:] ~ \\ |
57983
6edc3529bb4e
reordered some (co)datatype property names for more consistency
blanchet
parents:
57982
diff
changeset
|
917 |
@{thm list.map_sel[no_vars]} |
57047 | 918 |
|
69505 | 919 |
\item[\<open>t.\<close>\hthm{pred_inject} \<open>[simp]\<close>\rm:] ~ \\ |
62384 | 920 |
@{thm list.pred_inject(1)[no_vars]} \\ |
921 |
@{thm list.pred_inject(2)[no_vars]} |
|
922 |
||
69505 | 923 |
\item[\<open>t.\<close>\hthm{rel_inject} \<open>[simp]\<close>\rm:] ~ \\ |
53552 | 924 |
@{thm list.rel_inject(1)[no_vars]} \\ |
925 |
@{thm list.rel_inject(2)[no_vars]} |
|
926 |
||
69505 | 927 |
\item[\<open>t.\<close>\hthm{rel_distinct} \<open>[simp]\<close>\rm:] ~ \\ |
57526 | 928 |
@{thm list.rel_distinct(1)[no_vars]} \\ |
929 |
@{thm list.rel_distinct(2)[no_vars]} |
|
930 |
||
69505 | 931 |
\item[\<open>t.\<close>\hthm{rel_intros}\rm:] ~ \\ |
57494 | 932 |
@{thm list.rel_intros(1)[no_vars]} \\ |
933 |
@{thm list.rel_intros(2)[no_vars]} |
|
934 |
||
69505 | 935 |
\item[\<open>t.\<close>\hthm{rel_cases} \<open>[consumes 1, case_names t\<^sub>1 \<dots> t\<^sub>m, cases pred]\<close>\rm:] ~ \\ |
58474 | 936 |
@{thm list.rel_cases[no_vars]} |
53552 | 937 |
|
69505 | 938 |
\item[\<open>t.\<close>\hthm{rel_sel}\rm:] ~ \\ |
57564 | 939 |
@{thm list.rel_sel[no_vars]} |
940 |
||
53552 | 941 |
\end{description} |
942 |
\end{indentblock} |
|
54146 | 943 |
|
944 |
\noindent |
|
69505 | 945 |
In addition, equational versions of \<open>t.rel_inject\<close> and \<open>rel_distinct\<close> are registered with the \<open>[code]\<close> attribute. The |
946 |
\<open>[code]\<close> attribute is set by the \<open>code\<close> plugin |
|
59284 | 947 |
(Section~\ref{ssec:code-generator}). |
54621 | 948 |
|
949 |
The second subgroup consists of more abstract properties of the set functions, |
|
62330 | 950 |
the map function, the predicator, and the relator: |
54621 | 951 |
|
952 |
\begin{indentblock} |
|
953 |
\begin{description} |
|
954 |
||
69505 | 955 |
\item[\<open>t.\<close>\hthm{inj_map}\rm:] ~ \\ |
57969 | 956 |
@{thm list.inj_map[no_vars]} |
957 |
||
69505 | 958 |
\item[\<open>t.\<close>\hthm{inj_map_strong}\rm:] ~ \\ |
57971 | 959 |
@{thm list.inj_map_strong[no_vars]} |
960 |
||
69505 | 961 |
\item[\<open>t.\<close>\hthm{map_comp}\rm:] ~ \\ |
62330 | 962 |
@{thm list.map_comp[no_vars]} |
58107 | 963 |
|
69505 | 964 |
\item[\<open>t.\<close>\hthm{map_cong0}\rm:] ~ \\ |
54621 | 965 |
@{thm list.map_cong0[no_vars]} |
966 |
||
69505 | 967 |
\item[\<open>t.\<close>\hthm{map_cong} \<open>[fundef_cong]\<close>\rm:] ~ \\ |
54621 | 968 |
@{thm list.map_cong[no_vars]} |
969 |
||
69505 | 970 |
\item[\<open>t.\<close>\hthm{map_cong_pred}\rm:] ~ \\ |
62330 | 971 |
@{thm list.map_cong_pred[no_vars]} |
972 |
||
69505 | 973 |
\item[\<open>t.\<close>\hthm{map_cong_simp}\rm:] ~ \\ |
57982 | 974 |
@{thm list.map_cong_simp[no_vars]} |
975 |
||
69505 | 976 |
\item[\<open>t.\<close>\hthm{map_id0}\rm:] ~ \\ |
59793 | 977 |
@{thm list.map_id0[no_vars]} |
978 |
||
69505 | 979 |
\item[\<open>t.\<close>\hthm{map_id}\rm:] ~ \\ |
54621 | 980 |
@{thm list.map_id[no_vars]} |
981 |
||
69505 | 982 |
\item[\<open>t.\<close>\hthm{map_ident}\rm:] ~ \\ |
56904 | 983 |
@{thm list.map_ident[no_vars]} |
984 |
||
75276 | 985 |
\item[\<open>t.\<close>\hthm{map_ident_strong}\rm:] ~ \\ |
986 |
@{thm list.map_ident_strong[no_vars]} |
|
987 |
||
69505 | 988 |
\item[\<open>t.\<close>\hthm{map_transfer} \<open>[transfer_rule]\<close>\rm:] ~ \\ |
58915 | 989 |
@{thm list.map_transfer[no_vars]} \\ |
69505 | 990 |
The \<open>[transfer_rule]\<close> attribute is set by the \<open>transfer\<close> plugin |
59824 | 991 |
(Section~\ref{ssec:transfer}) for type constructors with no dead type arguments. |
58103 | 992 |
|
69505 | 993 |
\item[\<open>t.\<close>\hthm{pred_cong} \<open>[fundef_cong]\<close>\rm:] ~ \\ |
62330 | 994 |
@{thm list.pred_cong[no_vars]} |
995 |
||
69505 | 996 |
\item[\<open>t.\<close>\hthm{pred_cong_simp}\rm:] ~ \\ |
62330 | 997 |
@{thm list.pred_cong_simp[no_vars]} |
998 |
||
69505 | 999 |
\item[\<open>t.\<close>\hthm{pred_map}\rm:] ~ \\ |
62330 | 1000 |
@{thm list.pred_map[no_vars]} |
1001 |
||
74666 | 1002 |
\item[\<open>t.\<close>\hthm{pred_mono} \<open>[mono]\<close>\rm:] ~ \\ |
1003 |
@{thm list.pred_mono[no_vars]} |
|
1004 |
||
69505 | 1005 |
\item[\<open>t.\<close>\hthm{pred_mono_strong}\rm:] ~ \\ |
62330 | 1006 |
@{thm list.pred_mono_strong[no_vars]} |
1007 |
||
69505 | 1008 |
\item[\<open>t.\<close>\hthm{pred_rel}\rm:] ~ \\ |
62330 | 1009 |
@{thm list.pred_rel[no_vars]} |
1010 |
||
69505 | 1011 |
\item[\<open>t.\<close>\hthm{pred_set}\rm:] ~ \\ |
62330 | 1012 |
@{thm list.pred_set[no_vars]} |
1013 |
||
69505 | 1014 |
\item[\<open>t.\<close>\hthm{pred_transfer} \<open>[transfer_rule]\<close>\rm:] ~ \\ |
62330 | 1015 |
@{thm list.pred_transfer[no_vars]} \\ |
69505 | 1016 |
The \<open>[transfer_rule]\<close> attribute is set by the \<open>transfer\<close> plugin |
62330 | 1017 |
(Section~\ref{ssec:transfer}) for type constructors with no dead type arguments. |
1018 |
||
69505 | 1019 |
\item[\<open>t.\<close>\hthm{pred_True}\rm:] ~ \\ |
62330 | 1020 |
@{thm list.pred_True[no_vars]} |
1021 |
||
69505 | 1022 |
\item[\<open>t.\<close>\hthm{set_map}\rm:] ~ \\ |
62330 | 1023 |
@{thm list.set_map[no_vars]} |
1024 |
||
69505 | 1025 |
\item[\<open>t.\<close>\hthm{set_transfer} \<open>[transfer_rule]\<close>\rm:] ~ \\ |
62330 | 1026 |
@{thm list.set_transfer[no_vars]} \\ |
69505 | 1027 |
The \<open>[transfer_rule]\<close> attribute is set by the \<open>transfer\<close> plugin |
62330 | 1028 |
(Section~\ref{ssec:transfer}) for type constructors with no dead type arguments. |
1029 |
||
69505 | 1030 |
\item[\<open>t.\<close>\hthm{rel_compp} \<open>[relator_distr]\<close>\rm:] ~ \\ |
58245 | 1031 |
@{thm list.rel_compp[no_vars]} \\ |
69505 | 1032 |
The \<open>[relator_distr]\<close> attribute is set by the \<open>lifting\<close> plugin |
59284 | 1033 |
(Section~\ref{ssec:lifting}). |
54621 | 1034 |
|
69505 | 1035 |
\item[\<open>t.\<close>\hthm{rel_conversep}\rm:] ~ \\ |
54621 | 1036 |
@{thm list.rel_conversep[no_vars]} |
1037 |
||
69505 | 1038 |
\item[\<open>t.\<close>\hthm{rel_eq}\rm:] ~ \\ |
54621 | 1039 |
@{thm list.rel_eq[no_vars]} |
1040 |
||
69505 | 1041 |
\item[\<open>t.\<close>\hthm{rel_eq_onp}\rm:] ~ \\ |
62330 | 1042 |
@{thm list.rel_eq_onp[no_vars]} |
1043 |
||
69505 | 1044 |
\item[\<open>t.\<close>\hthm{rel_flip}\rm:] ~ \\ |
54621 | 1045 |
@{thm list.rel_flip[no_vars]} |
1046 |
||
69505 | 1047 |
\item[\<open>t.\<close>\hthm{rel_map}\rm:] ~ \\ |
57933 | 1048 |
@{thm list.rel_map(1)[no_vars]} \\ |
1049 |
@{thm list.rel_map(2)[no_vars]} |
|
1050 |
||
69505 | 1051 |
\item[\<open>t.\<close>\hthm{rel_mono} \<open>[mono, relator_mono]\<close>\rm:] ~ \\ |
58245 | 1052 |
@{thm list.rel_mono[no_vars]} \\ |
69505 | 1053 |
The \<open>[relator_mono]\<close> attribute is set by the \<open>lifting\<close> plugin |
59284 | 1054 |
(Section~\ref{ssec:lifting}). |
54621 | 1055 |
|
69505 | 1056 |
\item[\<open>t.\<close>\hthm{rel_mono_strong}\rm:] ~ \\ |
61242 | 1057 |
@{thm list.rel_mono_strong[no_vars]} |
1058 |
||
69505 | 1059 |
\item[\<open>t.\<close>\hthm{rel_cong} \<open>[fundef_cong]\<close>\rm:] ~ \\ |
61242 | 1060 |
@{thm list.rel_cong[no_vars]} |
1061 |
||
69505 | 1062 |
\item[\<open>t.\<close>\hthm{rel_cong_simp}\rm:] ~ \\ |
61242 | 1063 |
@{thm list.rel_cong_simp[no_vars]} |
1064 |
||
69505 | 1065 |
\item[\<open>t.\<close>\hthm{rel_refl}\rm:] ~ \\ |
59793 | 1066 |
@{thm list.rel_refl[no_vars]} |
1067 |
||
69505 | 1068 |
\item[\<open>t.\<close>\hthm{rel_refl_strong}\rm:] ~ \\ |
61240 | 1069 |
@{thm list.rel_refl_strong[no_vars]} |
1070 |
||
69505 | 1071 |
\item[\<open>t.\<close>\hthm{rel_reflp}\rm:] ~ \\ |
61240 | 1072 |
@{thm list.rel_reflp[no_vars]} |
1073 |
||
69505 | 1074 |
\item[\<open>t.\<close>\hthm{rel_symp}\rm:] ~ \\ |
61240 | 1075 |
@{thm list.rel_symp[no_vars]} |
1076 |
||
69505 | 1077 |
\item[\<open>t.\<close>\hthm{rel_transp}\rm:] ~ \\ |
61240 | 1078 |
@{thm list.rel_transp[no_vars]} |
1079 |
||
69505 | 1080 |
\item[\<open>t.\<close>\hthm{rel_transfer} \<open>[transfer_rule]\<close>\rm:] ~ \\ |
58915 | 1081 |
@{thm list.rel_transfer[no_vars]} \\ |
69505 | 1082 |
The \<open>[transfer_rule]\<close> attribute is set by the \<open>transfer\<close> plugin |
59824 | 1083 |
(Section~\ref{ssec:transfer}) for type constructors with no dead type arguments. |
58105 | 1084 |
|
54621 | 1085 |
\end{description} |
1086 |
\end{indentblock} |
|
62081 | 1087 |
\<close> |
1088 |
||
1089 |
||
62731 | 1090 |
subsubsection \<open>Inductive Theorems |
1091 |
\label{sssec:inductive-theorems}\<close> |
|
62081 | 1092 |
|
1093 |
text \<open> |
|
53623 | 1094 |
The inductive theorems are as follows: |
53544 | 1095 |
|
53552 | 1096 |
\begin{indentblock} |
53544 | 1097 |
\begin{description} |
1098 |
||
69505 | 1099 |
\item[\<open>t.\<close>\hthm{induct} \<open>[case_names C\<^sub>1 \<dots> C\<^sub>n, induct t]\<close>\rm:] ~ \\ |
53544 | 1100 |
@{thm list.induct[no_vars]} |
1101 |
||
69505 | 1102 |
\item[\<open>t.\<close>\hthm{rel_induct} \<open>[case_names C\<^sub>1 \<dots> C\<^sub>n, induct pred]\<close>\rm:] ~ \\ |
57472 | 1103 |
@{thm list.rel_induct[no_vars]} |
1104 |
||
57701 | 1105 |
\item[\begin{tabular}{@ {}l@ {}} |
69505 | 1106 |
\<open>t\<^sub>1_\<dots>_t\<^sub>m.\<close>\hthm{induct} \<open>[case_names C\<^sub>1 \<dots> C\<^sub>n]\<close>\rm: \\ |
1107 |
\<open>t\<^sub>1_\<dots>_t\<^sub>m.\<close>\hthm{rel_induct} \<open>[case_names C\<^sub>1 \<dots> C\<^sub>n]\<close>\rm: \\ |
|
57701 | 1108 |
\end{tabular}] ~ \\ |
57472 | 1109 |
Given $m > 1$ mutually recursive datatypes, this induction rule can be used to |
1110 |
prove $m$ properties simultaneously. |
|
1111 |
||
69505 | 1112 |
\item[\<open>t.\<close>\hthm{rec} \<open>[simp, code]\<close>\rm:] ~ \\ |
53544 | 1113 |
@{thm list.rec(1)[no_vars]} \\ |
58335
a5a3b576fcfb
generate 'code' attribute only if 'code' plugin is enabled
blanchet
parents:
58311
diff
changeset
|
1114 |
@{thm list.rec(2)[no_vars]} \\ |
69505 | 1115 |
The \<open>[code]\<close> attribute is set by the \<open>code\<close> plugin |
59284 | 1116 |
(Section~\ref{ssec:code-generator}). |
53544 | 1117 |
|
69505 | 1118 |
\item[\<open>t.\<close>\hthm{rec_o_map}\rm:] ~ \\ |
58733 | 1119 |
@{thm list.rec_o_map[no_vars]} |
1120 |
||
69505 | 1121 |
\item[\<open>t.\<close>\hthm{rec_transfer} \<open>[transfer_rule]\<close>\rm:] ~ \\ |
58915 | 1122 |
@{thm list.rec_transfer[no_vars]} \\ |
69505 | 1123 |
The \<open>[transfer_rule]\<close> attribute is set by the \<open>transfer\<close> plugin |
59824 | 1124 |
(Section~\ref{ssec:transfer}) for type constructors with no dead type arguments. |
58447 | 1125 |
|
53544 | 1126 |
\end{description} |
53552 | 1127 |
\end{indentblock} |
53544 | 1128 |
|
1129 |
\noindent |
|
58310 | 1130 |
For convenience, @{command datatype} also provides the following collection: |
53544 | 1131 |
|
53552 | 1132 |
\begin{indentblock} |
53544 | 1133 |
\begin{description} |
1134 |
||
69505 | 1135 |
\item[\<open>t.\<close>\hthm{simps}] = \<open>t.inject\<close> \<open>t.distinct\<close> \<open>t.case\<close> \<open>t.rec\<close> \<open>t.map\<close> \<open>t.rel_inject\<close> \\ |
1136 |
\<open>t.rel_distinct\<close> \<open>t.set\<close> |
|
53544 | 1137 |
|
1138 |
\end{description} |
|
53552 | 1139 |
\end{indentblock} |
62081 | 1140 |
\<close> |
1141 |
||
1142 |
||
62731 | 1143 |
subsection \<open>Proof Method |
1144 |
\label{ssec:datatype-proof-method}\<close> |
|
1145 |
||
1146 |
subsubsection \<open>\textit{countable_datatype} |
|
1147 |
\label{sssec:datatype-compat}\<close> |
|
62081 | 1148 |
|
1149 |
text \<open> |
|
63680 | 1150 |
The theory \<^file>\<open>~~/src/HOL/Library/Countable.thy\<close> provides a |
62756 | 1151 |
proof method called @{method countable_datatype} that can be used to prove the |
62081 | 1152 |
countability of many datatypes, building on the countability of the types |
1153 |
appearing in their definitions and of any type arguments. For example: |
|
1154 |
\<close> |
|
1155 |
||
1156 |
instance list :: (countable) countable |
|
1157 |
by countable_datatype |
|
1158 |
||
1159 |
||
70820
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
1160 |
subsection \<open>Antiquotation |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
1161 |
\label{ssec:datatype-antiquotation}\<close> |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
1162 |
|
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
1163 |
subsubsection \<open>\textit{datatype} |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
1164 |
\label{sssec:datatype-datatype}\<close> |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
1165 |
|
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
1166 |
text \<open> |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
1167 |
The \textit{datatype} antiquotation, written |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
1168 |
\texttt{\char`\\\char`<\char`^}\verb|datatype>|\guilsinglleft\textit{t}\guilsinglright{} |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
1169 |
or \texttt{@}\verb|{datatype| \textit{t}\verb|}|, where \textit{t} is a type |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
1170 |
name, expands to \LaTeX{} code for the definition of the datatype, with each |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
1171 |
constructor listed with its argument types. For example, if \textit{t} is |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
1172 |
@{type option}: |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
1173 |
|
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
1174 |
\begin{quote} |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
1175 |
\<^datatype>\<open>option\<close> |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
1176 |
\end{quote} |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
1177 |
\<close> |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
1178 |
|
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
1179 |
|
62731 | 1180 |
subsection \<open>Compatibility Issues |
1181 |
\label{ssec:datatype-compatibility-issues}\<close> |
|
62081 | 1182 |
|
1183 |
text \<open> |
|
1184 |
The command @{command datatype} has been designed to be highly compatible with |
|
70820
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
1185 |
the old, pre-Isabelle2015 command, to ease migration. There are nonetheless a |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
1186 |
few incompatibilities that may arise when porting: |
53647 | 1187 |
|
1188 |
\begin{itemize} |
|
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
1189 |
\setlength{\itemsep}{0pt} |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
1190 |
|
53647 | 1191 |
\item \emph{The Standard ML interfaces are different.} Tools and extensions |
1192 |
written to call the old ML interfaces will need to be adapted to the new |
|
69505 | 1193 |
interfaces. The \<open>BNF_LFP_Compat\<close> structure provides convenience functions |
60135
852f7a49ec0c
updated docs, esp. relating to 'datatype_compat'
blanchet
parents:
60134
diff
changeset
|
1194 |
that simulate the old interfaces in terms of the new ones. |
54537 | 1195 |
|
69505 | 1196 |
\item \emph{The recursor \<open>rec_t\<close> has a different signature for nested |
54185 | 1197 |
recursive datatypes.} In the old package, nested recursion through non-functions |
1198 |
was internally reduced to mutual recursion. This reduction was visible in the |
|
1199 |
type of the recursor, used by \keyw{primrec}. Recursion through functions was |
|
1200 |
handled specially. In the new package, nested recursion (for functions and |
|
1201 |
non-functions) is handled in a more modular fashion. The old-style recursor can |
|
56655 | 1202 |
be generated on demand using @{command primrec} if the recursion is via |
1203 |
new-style datatypes, as explained in |
|
61351 | 1204 |
Section~\ref{sssec:primrec-nested-as-mutual-recursion}, or using |
1205 |
@{command datatype_compat}. |
|
53647 | 1206 |
|
54287 | 1207 |
\item \emph{Accordingly, the induction rule is different for nested recursive |
61351 | 1208 |
datatypes.} Again, the old-style induction rule can be generated on demand |
1209 |
using @{command primrec} if the recursion is via new-style datatypes, as |
|
1210 |
explained in Section~\ref{sssec:primrec-nested-as-mutual-recursion}, or using |
|
1211 |
@{command datatype_compat}. For recursion through functions, the old-style |
|
69505 | 1212 |
induction rule can be obtained by applying the \<open>[unfolded |
1213 |
all_mem_range]\<close> attribute on \<open>t.induct\<close>. |
|
52828 | 1214 |
|
69597 | 1215 |
\item \emph{The \<^const>\<open>size\<close> function has a slightly different definition.} |
69505 | 1216 |
The new function returns \<open>1\<close> instead of \<open>0\<close> for some nonrecursive |
58336 | 1217 |
constructors. This departure from the old behavior made it possible to implement |
69597 | 1218 |
\<^const>\<open>size\<close> in terms of the generic function \<open>t.size_t\<close>. Moreover, |
62081 | 1219 |
the new function considers nested occurrences of a value, in the nested |
69505 | 1220 |
recursive case. The old behavior can be obtained by disabling the \<open>size\<close> |
59282 | 1221 |
plugin (Section~\ref{sec:selecting-plugins}) and instantiating the |
69505 | 1222 |
\<open>size\<close> type class manually. |
58336 | 1223 |
|
53863
c7364dca96f2
textual improvements following Christian Sternagel's feedback
blanchet
parents:
53857
diff
changeset
|
1224 |
\item \emph{The internal constructions are completely different.} Proof texts |
62081 | 1225 |
that unfold the definition of constants introduced by the old command will |
58305
57752a91eec4
renamed 'datatype' to 'old_datatype'; 'datatype' is now alias for 'datatype_new'
blanchet
parents:
58298
diff
changeset
|
1226 |
be difficult to port. |
53647 | 1227 |
|
58207 | 1228 |
\item \emph{Some constants and theorems have different names.} |
55641
5b466efedd2c
renamed 'recs' and 'cases' theorems 'rec' and 'case' in old datatype package, for consistency with new package
blanchet
parents:
55531
diff
changeset
|
1229 |
For non-mutually recursive datatypes, |
69505 | 1230 |
the alias \<open>t.inducts\<close> for \<open>t.induct\<close> is no longer generated. |
53647 | 1231 |
For $m > 1$ mutually recursive datatypes, |
69505 | 1232 |
\<open>rec_t\<^sub>1_\<dots>_t\<^sub>m_i\<close> has been renamed |
1233 |
\<open>rec_t\<^sub>i\<close> for each \<open>i \<in> {1, \<dots>, m}\<close>, |
|
1234 |
\<open>t\<^sub>1_\<dots>_t\<^sub>m.inducts(i)\<close> has been renamed |
|
1235 |
\<open>t\<^sub>i.induct\<close> for each \<open>i \<in> {1, \<dots>, m}\<close>, and the |
|
1236 |
collection \<open>t\<^sub>1_\<dots>_t\<^sub>m.size\<close> (generated by the |
|
1237 |
\<open>size\<close> plugin, Section~\ref{ssec:size}) has been divided into |
|
1238 |
\<open>t\<^sub>1.size\<close>, \ldots, \<open>t\<^sub>m.size\<close>. |
|
1239 |
||
1240 |
\item \emph{The \<open>t.simps\<close> collection has been extended.} |
|
58207 | 1241 |
Previously available theorems are available at the same index as before. |
53647 | 1242 |
|
1243 |
\item \emph{Variables in generated properties have different names.} This is |
|
1244 |
rarely an issue, except in proof texts that refer to variable names in the |
|
69505 | 1245 |
\<open>[where \<dots>]\<close> attribute. The solution is to use the more robust |
1246 |
\<open>[of \<dots>]\<close> syntax. |
|
53647 | 1247 |
\end{itemize} |
62081 | 1248 |
\<close> |
1249 |
||
1250 |
||
62731 | 1251 |
section \<open>Defining Primitively Recursive Functions |
1252 |
\label{sec:defining-primitively-recursive-functions}\<close> |
|
62081 | 1253 |
|
1254 |
text \<open> |
|
55530
3dfb724db099
renamed 'primrec_new' to 'primrec', overriding the old command (which it still uses as a fallback for old-style datatypes)
blanchet
parents:
55474
diff
changeset
|
1255 |
Recursive functions over datatypes can be specified using the @{command primrec} |
70818
13d6b561b0ea
added para constrasting 'primrec' and 'fun' -- and removed my middle name
blanchet
parents:
70078
diff
changeset
|
1256 |
command, which supports primitive recursion, or using the \keyw{fun}, |
13d6b561b0ea
added para constrasting 'primrec' and 'fun' -- and removed my middle name
blanchet
parents:
70078
diff
changeset
|
1257 |
\keyw{function}, and \keyw{partial_function} commands. In this tutorial, the |
13d6b561b0ea
added para constrasting 'primrec' and 'fun' -- and removed my middle name
blanchet
parents:
70078
diff
changeset
|
1258 |
focus is on @{command primrec}; \keyw{fun} and \keyw{function} are described in |
76987 | 1259 |
a separate tutorial \<^cite>\<open>"isabelle-function"\<close>. |
70818
13d6b561b0ea
added para constrasting 'primrec' and 'fun' -- and removed my middle name
blanchet
parents:
70078
diff
changeset
|
1260 |
|
13d6b561b0ea
added para constrasting 'primrec' and 'fun' -- and removed my middle name
blanchet
parents:
70078
diff
changeset
|
1261 |
Because it is restricted to primitive recursion, @{command primrec} is less |
13d6b561b0ea
added para constrasting 'primrec' and 'fun' -- and removed my middle name
blanchet
parents:
70078
diff
changeset
|
1262 |
powerful than \keyw{fun} and \keyw{function}. However, there are primitively |
13d6b561b0ea
added para constrasting 'primrec' and 'fun' -- and removed my middle name
blanchet
parents:
70078
diff
changeset
|
1263 |
recursive specifications (e.g., based on infinitely branching or mutually |
13d6b561b0ea
added para constrasting 'primrec' and 'fun' -- and removed my middle name
blanchet
parents:
70078
diff
changeset
|
1264 |
recursive datatypes) for which \keyw{fun}'s termination check fails. It is also |
13d6b561b0ea
added para constrasting 'primrec' and 'fun' -- and removed my middle name
blanchet
parents:
70078
diff
changeset
|
1265 |
good style to use the simpler @{command primrec} mechanism when it works, both |
13d6b561b0ea
added para constrasting 'primrec' and 'fun' -- and removed my middle name
blanchet
parents:
70078
diff
changeset
|
1266 |
as an optimization and as documentation. |
62081 | 1267 |
\<close> |
1268 |
||
1269 |
||
62731 | 1270 |
subsection \<open>Introductory Examples |
1271 |
\label{ssec:primrec-introductory-examples}\<close> |
|
62081 | 1272 |
|
1273 |
text \<open> |
|
53646 | 1274 |
Primitive recursion is illustrated through concrete examples based on the |
1275 |
datatypes defined in Section~\ref{ssec:datatype-introductory-examples}. More |
|
63680 | 1276 |
examples can be found in the directory \<^dir>\<open>~~/src/HOL/Datatype_Examples\<close>. |
62081 | 1277 |
\<close> |
1278 |
||
1279 |
||
62731 | 1280 |
subsubsection \<open>Nonrecursive Types |
1281 |
\label{sssec:primrec-nonrecursive-types}\<close> |
|
62081 | 1282 |
|
1283 |
text \<open> |
|
53621 | 1284 |
Primitive recursion removes one layer of constructors on the left-hand side in |
1285 |
each equation. For example: |
|
62081 | 1286 |
\<close> |
52841 | 1287 |
|
60136 | 1288 |
primrec (nonexhaustive) bool_of_trool :: "trool \<Rightarrow> bool" where |
62081 | 1289 |
"bool_of_trool Faalse \<longleftrightarrow> False" |
1290 |
| "bool_of_trool Truue \<longleftrightarrow> True" |
|
1291 |
||
62731 | 1292 |
text \<open>\blankline\<close> |
52841 | 1293 |
|
55530
3dfb724db099
renamed 'primrec_new' to 'primrec', overriding the old command (which it still uses as a fallback for old-style datatypes)
blanchet
parents:
55474
diff
changeset
|
1294 |
primrec the_list :: "'a option \<Rightarrow> 'a list" where |
62081 | 1295 |
"the_list None = []" |
1296 |
| "the_list (Some a) = [a]" |
|
1297 |
||
62731 | 1298 |
text \<open>\blankline\<close> |
53621 | 1299 |
|
55530
3dfb724db099
renamed 'primrec_new' to 'primrec', overriding the old command (which it still uses as a fallback for old-style datatypes)
blanchet
parents:
55474
diff
changeset
|
1300 |
primrec the_default :: "'a \<Rightarrow> 'a option \<Rightarrow> 'a" where |
62081 | 1301 |
"the_default d None = d" |
1302 |
| "the_default _ (Some a) = a" |
|
1303 |
||
62731 | 1304 |
text \<open>\blankline\<close> |
53621 | 1305 |
|
55530
3dfb724db099
renamed 'primrec_new' to 'primrec', overriding the old command (which it still uses as a fallback for old-style datatypes)
blanchet
parents:
55474
diff
changeset
|
1306 |
primrec mirrror :: "('a, 'b, 'c) triple \<Rightarrow> ('c, 'b, 'a) triple" where |
52841 | 1307 |
"mirrror (Triple a b c) = Triple c b a" |
1308 |
||
62081 | 1309 |
text \<open> |
53621 | 1310 |
\noindent |
1311 |
The equations can be specified in any order, and it is acceptable to leave out |
|
1312 |
some cases, which are then unspecified. Pattern matching on the left-hand side |
|
1313 |
is restricted to a single datatype, which must correspond to the same argument |
|
1314 |
in all equations. |
|
62081 | 1315 |
\<close> |
1316 |
||
1317 |
||
62731 | 1318 |
subsubsection \<open>Simple Recursion |
1319 |
\label{sssec:primrec-simple-recursion}\<close> |
|
62081 | 1320 |
|
1321 |
text \<open> |
|
53621 | 1322 |
For simple recursive types, recursive calls on a constructor argument are |
1323 |
allowed on the right-hand side: |
|
62081 | 1324 |
\<close> |
52841 | 1325 |
|
55530
3dfb724db099
renamed 'primrec_new' to 'primrec', overriding the old command (which it still uses as a fallback for old-style datatypes)
blanchet
parents:
55474
diff
changeset
|
1326 |
primrec replicate :: "nat \<Rightarrow> 'a \<Rightarrow> 'a list" where |
62081 | 1327 |
"replicate Zero _ = []" |
1328 |
| "replicate (Succ n) x = x # replicate n x" |
|
1329 |
||
62731 | 1330 |
text \<open>\blankline\<close> |
52843 | 1331 |
|
60136 | 1332 |
primrec (nonexhaustive) at :: "'a list \<Rightarrow> nat \<Rightarrow> 'a" where |
53644 | 1333 |
"at (x # xs) j = |
52843 | 1334 |
(case j of |
53644 | 1335 |
Zero \<Rightarrow> x |
58245 | 1336 |
| Succ j' \<Rightarrow> at xs j')" |
52843 | 1337 |
|
62731 | 1338 |
text \<open>\blankline\<close> |
53621 | 1339 |
|
59284 | 1340 |
primrec (*<*)(in early) (transfer) (*>*)tfold :: "('a \<Rightarrow> 'b \<Rightarrow> 'b) \<Rightarrow> ('a, 'b) tlist \<Rightarrow> 'b" where |
62081 | 1341 |
"tfold _ (TNil y) = y" |
1342 |
| "tfold f (TCons x xs) = f x (tfold f xs)" |
|
1343 |
||
1344 |
text \<open> |
|
53621 | 1345 |
\noindent |
54402 | 1346 |
Pattern matching is only available for the argument on which the recursion takes |
1347 |
place. Fortunately, it is easy to generate pattern-maching equations using the |
|
62081 | 1348 |
@{command simps_of_case} command provided by the theory |
63680 | 1349 |
\<^file>\<open>~~/src/HOL/Library/Simps_Case_Conv.thy\<close>. |
62081 | 1350 |
\<close> |
1351 |
||
1352 |
simps_of_case at_simps_alt: at.simps |
|
1353 |
||
1354 |
text \<open> |
|
1355 |
This generates the lemma collection @{thm [source] at_simps_alt}: |
|
54402 | 1356 |
% |
62081 | 1357 |
\[@{thm at_simps_alt(1)[no_vars]} |
1358 |
\qquad @{thm at_simps_alt(2)[no_vars]}\] |
|
54402 | 1359 |
% |
54184 | 1360 |
The next example is defined using \keyw{fun} to escape the syntactic |
60135
852f7a49ec0c
updated docs, esp. relating to 'datatype_compat'
blanchet
parents:
60134
diff
changeset
|
1361 |
restrictions imposed on primitively recursive functions: |
62081 | 1362 |
\<close> |
52828 | 1363 |
|
53621 | 1364 |
fun at_least_two :: "nat \<Rightarrow> bool" where |
62081 | 1365 |
"at_least_two (Succ (Succ _)) \<longleftrightarrow> True" |
1366 |
| "at_least_two _ \<longleftrightarrow> False" |
|
1367 |
||
1368 |
||
62731 | 1369 |
subsubsection \<open>Mutual Recursion |
1370 |
\label{sssec:primrec-mutual-recursion}\<close> |
|
62081 | 1371 |
|
1372 |
text \<open> |
|
53621 | 1373 |
The syntax for mutually recursive functions over mutually recursive datatypes |
1374 |
is straightforward: |
|
62081 | 1375 |
\<close> |
52841 | 1376 |
|
55530
3dfb724db099
renamed 'primrec_new' to 'primrec', overriding the old command (which it still uses as a fallback for old-style datatypes)
blanchet
parents:
55474
diff
changeset
|
1377 |
primrec |
53623 | 1378 |
nat_of_even_nat :: "even_nat \<Rightarrow> nat" and |
1379 |
nat_of_odd_nat :: "odd_nat \<Rightarrow> nat" |
|
52841 | 1380 |
where |
62081 | 1381 |
"nat_of_even_nat Even_Zero = Zero" |
1382 |
| "nat_of_even_nat (Even_Succ n) = Succ (nat_of_odd_nat n)" |
|
1383 |
| "nat_of_odd_nat (Odd_Succ n) = Succ (nat_of_even_nat n)" |
|
1384 |
||
62731 | 1385 |
text \<open>\blankline\<close> |
53752 | 1386 |
|
55530
3dfb724db099
renamed 'primrec_new' to 'primrec', overriding the old command (which it still uses as a fallback for old-style datatypes)
blanchet
parents:
55474
diff
changeset
|
1387 |
primrec |
53330
77da8d3c46e0
fixed docs w.r.t. availability of "primrec_new" and friends
blanchet
parents:
53262
diff
changeset
|
1388 |
eval\<^sub>e :: "('a \<Rightarrow> int) \<Rightarrow> ('b \<Rightarrow> int) \<Rightarrow> ('a, 'b) exp \<Rightarrow> int" and |
77da8d3c46e0
fixed docs w.r.t. availability of "primrec_new" and friends
blanchet
parents:
53262
diff
changeset
|
1389 |
eval\<^sub>t :: "('a \<Rightarrow> int) \<Rightarrow> ('b \<Rightarrow> int) \<Rightarrow> ('a, 'b) trm \<Rightarrow> int" and |
77da8d3c46e0
fixed docs w.r.t. availability of "primrec_new" and friends
blanchet
parents:
53262
diff
changeset
|
1390 |
eval\<^sub>f :: "('a \<Rightarrow> int) \<Rightarrow> ('b \<Rightarrow> int) \<Rightarrow> ('a, 'b) fct \<Rightarrow> int" |
52841 | 1391 |
where |
62081 | 1392 |
"eval\<^sub>e \<gamma> \<xi> (Term t) = eval\<^sub>t \<gamma> \<xi> t" |
1393 |
| "eval\<^sub>e \<gamma> \<xi> (Sum t e) = eval\<^sub>t \<gamma> \<xi> t + eval\<^sub>e \<gamma> \<xi> e" |
|
1394 |
| "eval\<^sub>t \<gamma> \<xi> (Factor f) = eval\<^sub>f \<gamma> \<xi> f" |
|
1395 |
| "eval\<^sub>t \<gamma> \<xi> (Prod f t) = eval\<^sub>f \<gamma> \<xi> f + eval\<^sub>t \<gamma> \<xi> t" |
|
1396 |
| "eval\<^sub>f \<gamma> _ (Const a) = \<gamma> a" |
|
1397 |
| "eval\<^sub>f _ \<xi> (Var b) = \<xi> b" |
|
1398 |
| "eval\<^sub>f \<gamma> \<xi> (Expr e) = eval\<^sub>e \<gamma> \<xi> e" |
|
1399 |
||
1400 |
text \<open> |
|
53621 | 1401 |
\noindent |
53647 | 1402 |
Mutual recursion is possible within a single type, using \keyw{fun}: |
62081 | 1403 |
\<close> |
52828 | 1404 |
|
53621 | 1405 |
fun |
1406 |
even :: "nat \<Rightarrow> bool" and |
|
1407 |
odd :: "nat \<Rightarrow> bool" |
|
1408 |
where |
|
62081 | 1409 |
"even Zero = True" |
1410 |
| "even (Succ n) = odd n" |
|
1411 |
| "odd Zero = False" |
|
1412 |
| "odd (Succ n) = even n" |
|
1413 |
||
1414 |
||
62731 | 1415 |
subsubsection \<open>Nested Recursion |
1416 |
\label{sssec:primrec-nested-recursion}\<close> |
|
62081 | 1417 |
|
1418 |
text \<open> |
|
53621 | 1419 |
In a departure from the old datatype package, nested recursion is normally |
1420 |
handled via the map functions of the nesting type constructors. For example, |
|
69597 | 1421 |
recursive calls are lifted to lists using \<^const>\<open>map\<close>: |
62081 | 1422 |
\<close> |
52828 | 1423 |
|
52843 | 1424 |
(*<*) |
58310 | 1425 |
datatype 'a tree\<^sub>f\<^sub>f = Node\<^sub>f\<^sub>f (lbl\<^sub>f\<^sub>f: 'a) (sub\<^sub>f\<^sub>f: "'a tree\<^sub>f\<^sub>f list") |
52843 | 1426 |
(*>*) |
55530
3dfb724db099
renamed 'primrec_new' to 'primrec', overriding the old command (which it still uses as a fallback for old-style datatypes)
blanchet
parents:
55474
diff
changeset
|
1427 |
primrec at\<^sub>f\<^sub>f :: "'a tree\<^sub>f\<^sub>f \<Rightarrow> nat list \<Rightarrow> 'a" where |
53028 | 1428 |
"at\<^sub>f\<^sub>f (Node\<^sub>f\<^sub>f a ts) js = |
52843 | 1429 |
(case js of |
1430 |
[] \<Rightarrow> a |
|
53028 | 1431 |
| j # js' \<Rightarrow> at (map (\<lambda>t. at\<^sub>f\<^sub>f t js') ts) j)" |
52843 | 1432 |
|
62081 | 1433 |
text \<open> |
53647 | 1434 |
\noindent |
69505 | 1435 |
The next example features recursion through the \<open>option\<close> type. Although |
1436 |
\<open>option\<close> is not a new-style datatype, it is registered as a BNF with the |
|
69597 | 1437 |
map function \<^const>\<open>map_option\<close>: |
62081 | 1438 |
\<close> |
52843 | 1439 |
|
61076 | 1440 |
primrec (*<*)(in early) (*>*)sum_btree :: "('a::{zero,plus}) btree \<Rightarrow> 'a" where |
52843 | 1441 |
"sum_btree (BNode a lt rt) = |
54491 | 1442 |
a + the_default 0 (map_option sum_btree lt) + |
1443 |
the_default 0 (map_option sum_btree rt)" |
|
52843 | 1444 |
|
62081 | 1445 |
text \<open> |
53621 | 1446 |
\noindent |
1447 |
The same principle applies for arbitrary type constructors through which |
|
1448 |
recursion is possible. Notably, the map function for the function type |
|
69505 | 1449 |
(\<open>\<Rightarrow>\<close>) is simply composition (\<open>(\<circ>)\<close>): |
62081 | 1450 |
\<close> |
52828 | 1451 |
|
55530
3dfb724db099
renamed 'primrec_new' to 'primrec', overriding the old command (which it still uses as a fallback for old-style datatypes)
blanchet
parents:
55474
diff
changeset
|
1452 |
primrec (*<*)(in early) (*>*)relabel_ft :: "('a \<Rightarrow> 'a) \<Rightarrow> 'a ftree \<Rightarrow> 'a ftree" where |
62081 | 1453 |
"relabel_ft f (FTLeaf x) = FTLeaf (f x)" |
1454 |
| "relabel_ft f (FTNode g) = FTNode (relabel_ft f \<circ> g)" |
|
1455 |
||
1456 |
text \<open> |
|
54182 | 1457 |
\noindent |
62336 | 1458 |
For convenience, recursion through functions can also be expressed using |
54182 | 1459 |
$\lambda$-abstractions and function application rather than through composition. |
1460 |
For example: |
|
62081 | 1461 |
\<close> |
54182 | 1462 |
|
55530
3dfb724db099
renamed 'primrec_new' to 'primrec', overriding the old command (which it still uses as a fallback for old-style datatypes)
blanchet
parents:
55474
diff
changeset
|
1463 |
primrec relabel_ft :: "('a \<Rightarrow> 'a) \<Rightarrow> 'a ftree \<Rightarrow> 'a ftree" where |
62081 | 1464 |
"relabel_ft f (FTLeaf x) = FTLeaf (f x)" |
1465 |
| "relabel_ft f (FTNode g) = FTNode (\<lambda>x. relabel_ft f (g x))" |
|
1466 |
||
62731 | 1467 |
text \<open>\blankline\<close> |
54183 | 1468 |
|
60136 | 1469 |
primrec (nonexhaustive) subtree_ft :: "'a \<Rightarrow> 'a ftree \<Rightarrow> 'a ftree" where |
54183 | 1470 |
"subtree_ft x (FTNode g) = g x" |
1471 |
||
62081 | 1472 |
text \<open> |
53621 | 1473 |
\noindent |
54182 | 1474 |
For recursion through curried $n$-ary functions, $n$ applications of |
69597 | 1475 |
\<^term>\<open>(\<circ>)\<close> are necessary. The examples below illustrate the case where |
54182 | 1476 |
$n = 2$: |
62081 | 1477 |
\<close> |
53621 | 1478 |
|
58310 | 1479 |
datatype 'a ftree2 = FTLeaf2 'a | FTNode2 "'a \<Rightarrow> 'a \<Rightarrow> 'a ftree2" |
54182 | 1480 |
|
62731 | 1481 |
text \<open>\blankline\<close> |
54182 | 1482 |
|
55530
3dfb724db099
renamed 'primrec_new' to 'primrec', overriding the old command (which it still uses as a fallback for old-style datatypes)
blanchet
parents:
55474
diff
changeset
|
1483 |
primrec (*<*)(in early) (*>*)relabel_ft2 :: "('a \<Rightarrow> 'a) \<Rightarrow> 'a ftree2 \<Rightarrow> 'a ftree2" where |
62081 | 1484 |
"relabel_ft2 f (FTLeaf2 x) = FTLeaf2 (f x)" |
67399 | 1485 |
| "relabel_ft2 f (FTNode2 g) = FTNode2 ((\<circ>) ((\<circ>) (relabel_ft2 f)) g)" |
62081 | 1486 |
|
62731 | 1487 |
text \<open>\blankline\<close> |
54182 | 1488 |
|
55530
3dfb724db099
renamed 'primrec_new' to 'primrec', overriding the old command (which it still uses as a fallback for old-style datatypes)
blanchet
parents:
55474
diff
changeset
|
1489 |
primrec relabel_ft2 :: "('a \<Rightarrow> 'a) \<Rightarrow> 'a ftree2 \<Rightarrow> 'a ftree2" where |
62081 | 1490 |
"relabel_ft2 f (FTLeaf2 x) = FTLeaf2 (f x)" |
1491 |
| "relabel_ft2 f (FTNode2 g) = FTNode2 (\<lambda>x y. relabel_ft2 f (g x y))" |
|
1492 |
||
62731 | 1493 |
text \<open>\blankline\<close> |
54183 | 1494 |
|
60136 | 1495 |
primrec (nonexhaustive) subtree_ft2 :: "'a \<Rightarrow> 'a \<Rightarrow> 'a ftree2 \<Rightarrow> 'a ftree2" where |
54183 | 1496 |
"subtree_ft2 x y (FTNode2 g) = g x y" |
1497 |
||
62336 | 1498 |
text \<open> |
1499 |
For any datatype featuring nesting, the predicator can be used instead of the |
|
1500 |
map function, typically when defining predicates. For example: |
|
1501 |
\<close> |
|
1502 |
||
1503 |
primrec increasing_tree :: "int \<Rightarrow> int tree\<^sub>f\<^sub>f \<Rightarrow> bool" where |
|
62384 | 1504 |
"increasing_tree m (Node\<^sub>f\<^sub>f n ts) \<longleftrightarrow> |
1505 |
n \<ge> m \<and> list_all (increasing_tree (n + 1)) ts" |
|
62336 | 1506 |
|
53621 | 1507 |
|
62731 | 1508 |
subsubsection \<open>Nested-as-Mutual Recursion |
1509 |
\label{sssec:primrec-nested-as-mutual-recursion}\<close> |
|
53621 | 1510 |
|
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
1511 |
(*<*) |
59284 | 1512 |
locale n2m |
1513 |
begin |
|
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
1514 |
(*>*) |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
1515 |
|
62081 | 1516 |
text \<open> |
53621 | 1517 |
For compatibility with the old package, but also because it is sometimes |
1518 |
convenient in its own right, it is possible to treat nested recursive datatypes |
|
1519 |
as mutually recursive ones if the recursion takes place though new-style |
|
1520 |
datatypes. For example: |
|
62081 | 1521 |
\<close> |
52843 | 1522 |
|
60136 | 1523 |
primrec (nonexhaustive) |
53647 | 1524 |
at\<^sub>f\<^sub>f :: "'a tree\<^sub>f\<^sub>f \<Rightarrow> nat list \<Rightarrow> 'a" and |
1525 |
ats\<^sub>f\<^sub>f :: "'a tree\<^sub>f\<^sub>f list \<Rightarrow> nat \<Rightarrow> nat list \<Rightarrow> 'a" |
|
52843 | 1526 |
where |
53647 | 1527 |
"at\<^sub>f\<^sub>f (Node\<^sub>f\<^sub>f a ts) js = |
52843 | 1528 |
(case js of |
1529 |
[] \<Rightarrow> a |
|
62081 | 1530 |
| j # js' \<Rightarrow> ats\<^sub>f\<^sub>f ts j js')" |
1531 |
| "ats\<^sub>f\<^sub>f (t # ts) j = |
|
52843 | 1532 |
(case j of |
53647 | 1533 |
Zero \<Rightarrow> at\<^sub>f\<^sub>f t |
58245 | 1534 |
| Succ j' \<Rightarrow> ats\<^sub>f\<^sub>f ts j')" |
52843 | 1535 |
|
62081 | 1536 |
text \<open> |
53647 | 1537 |
\noindent |
54287 | 1538 |
Appropriate induction rules are generated as |
54031 | 1539 |
@{thm [source] at\<^sub>f\<^sub>f.induct}, |
1540 |
@{thm [source] ats\<^sub>f\<^sub>f.induct}, and |
|
54287 | 1541 |
@{thm [source] at\<^sub>f\<^sub>f_ats\<^sub>f\<^sub>f.induct}. The |
62384 | 1542 |
induction rules and the underlying recursors are generated dynamically |
54287 | 1543 |
and are kept in a cache to speed up subsequent definitions. |
53647 | 1544 |
|
1545 |
Here is a second example: |
|
62081 | 1546 |
\<close> |
53621 | 1547 |
|
55530
3dfb724db099
renamed 'primrec_new' to 'primrec', overriding the old command (which it still uses as a fallback for old-style datatypes)
blanchet
parents:
55474
diff
changeset
|
1548 |
primrec |
61076 | 1549 |
sum_btree :: "('a::{zero,plus}) btree \<Rightarrow> 'a" and |
53330
77da8d3c46e0
fixed docs w.r.t. availability of "primrec_new" and friends
blanchet
parents:
53262
diff
changeset
|
1550 |
sum_btree_option :: "'a btree option \<Rightarrow> 'a" |
52843 | 1551 |
where |
1552 |
"sum_btree (BNode a lt rt) = |
|
62081 | 1553 |
a + sum_btree_option lt + sum_btree_option rt" |
1554 |
| "sum_btree_option None = 0" |
|
1555 |
| "sum_btree_option (Some t) = sum_btree t" |
|
1556 |
||
1557 |
text \<open> |
|
53621 | 1558 |
% * can pretend a nested type is mutually recursive (if purely inductive) |
1559 |
% * avoids the higher-order map |
|
1560 |
% * e.g. |
|
1561 |
||
53617 | 1562 |
% * this can always be avoided; |
1563 |
% * e.g. in our previous example, we first mapped the recursive |
|
1564 |
% calls, then we used a generic at function to retrieve the result |
|
1565 |
% |
|
1566 |
% * there's no hard-and-fast rule of when to use one or the other, |
|
1567 |
% just like there's no rule when to use fold and when to use |
|
55530
3dfb724db099
renamed 'primrec_new' to 'primrec', overriding the old command (which it still uses as a fallback for old-style datatypes)
blanchet
parents:
55474
diff
changeset
|
1568 |
% primrec |
53617 | 1569 |
% |
1570 |
% * higher-order approach, considering nesting as nesting, is more |
|
1571 |
% compositional -- e.g. we saw how we could reuse an existing polymorphic |
|
69597 | 1572 |
% at or the_default, whereas \<^const>\<open>ats\<^sub>f\<^sub>f\<close> is much more specific |
53617 | 1573 |
% |
1574 |
% * but: |
|
1575 |
% * is perhaps less intuitive, because it requires higher-order thinking |
|
1576 |
% * may seem inefficient, and indeed with the code generator the |
|
1577 |
% mutually recursive version might be nicer |
|
1578 |
% * is somewhat indirect -- must apply a map first, then compute a result |
|
1579 |
% (cannot mix) |
|
69597 | 1580 |
% * the auxiliary functions like \<^const>\<open>ats\<^sub>f\<^sub>f\<close> are sometimes useful in own right |
53617 | 1581 |
% |
1582 |
% * impact on automation unclear |
|
1583 |
% |
|
62081 | 1584 |
\<close> |
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
1585 |
(*<*) |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
1586 |
end |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
1587 |
(*>*) |
52843 | 1588 |
|
52824 | 1589 |
|
62731 | 1590 |
subsection \<open>Command Syntax |
1591 |
\label{ssec:primrec-command-syntax}\<close> |
|
1592 |
||
1593 |
subsubsection \<open>\keyw{primrec} |
|
62740 | 1594 |
\label{sssec:primrec}\<close> |
62081 | 1595 |
|
1596 |
text \<open> |
|
53829 | 1597 |
\begin{matharray}{rcl} |
69505 | 1598 |
@{command_def "primrec"} & : & \<open>local_theory \<rightarrow> local_theory\<close> |
53829 | 1599 |
\end{matharray} |
52794 | 1600 |
|
69597 | 1601 |
\<^rail>\<open> |
59277 | 1602 |
@@{command primrec} target? @{syntax pr_options}? fixes \<newline> |
56123
a27859b0ef7d
document the new 'nonexhaustive' option (cf. 52e8f110fec3)
blanchet
parents:
55945
diff
changeset
|
1603 |
@'where' (@{syntax pr_equation} + '|') |
a27859b0ef7d
document the new 'nonexhaustive' option (cf. 52e8f110fec3)
blanchet
parents:
55945
diff
changeset
|
1604 |
; |
59282 | 1605 |
@{syntax_def pr_options}: '(' ((@{syntax plugins} | 'nonexhaustive' | 'transfer') + ',') ')' |
52840 | 1606 |
; |
53829 | 1607 |
@{syntax_def pr_equation}: thmdecl? prop |
69597 | 1608 |
\<close> |
55460
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
1609 |
|
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
1610 |
\medskip |
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
1611 |
|
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
1612 |
\noindent |
55530
3dfb724db099
renamed 'primrec_new' to 'primrec', overriding the old command (which it still uses as a fallback for old-style datatypes)
blanchet
parents:
55474
diff
changeset
|
1613 |
The @{command primrec} command introduces a set of mutually recursive functions |
3dfb724db099
renamed 'primrec_new' to 'primrec', overriding the old command (which it still uses as a fallback for old-style datatypes)
blanchet
parents:
55474
diff
changeset
|
1614 |
over datatypes. |
55460
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
1615 |
|
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
1616 |
The syntactic entity \synt{target} can be used to specify a local context, |
55474 | 1617 |
\synt{fixes} denotes a list of names with optional type signatures, |
1618 |
\synt{thmdecl} denotes an optional name for the formula that follows, and |
|
76987 | 1619 |
\synt{prop} denotes a HOL proposition \<^cite>\<open>"isabelle-isar-ref"\<close>. |
55460
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
1620 |
|
59280 | 1621 |
The optional target is optionally followed by a combination of the following |
1622 |
options: |
|
56123
a27859b0ef7d
document the new 'nonexhaustive' option (cf. 52e8f110fec3)
blanchet
parents:
55945
diff
changeset
|
1623 |
|
a27859b0ef7d
document the new 'nonexhaustive' option (cf. 52e8f110fec3)
blanchet
parents:
55945
diff
changeset
|
1624 |
\begin{itemize} |
a27859b0ef7d
document the new 'nonexhaustive' option (cf. 52e8f110fec3)
blanchet
parents:
55945
diff
changeset
|
1625 |
\setlength{\itemsep}{0pt} |
a27859b0ef7d
document the new 'nonexhaustive' option (cf. 52e8f110fec3)
blanchet
parents:
55945
diff
changeset
|
1626 |
|
a27859b0ef7d
document the new 'nonexhaustive' option (cf. 52e8f110fec3)
blanchet
parents:
55945
diff
changeset
|
1627 |
\item |
69505 | 1628 |
The \<open>plugins\<close> option indicates which plugins should be enabled |
1629 |
(\<open>only\<close>) or disabled (\<open>del\<close>). By default, all plugins are enabled. |
|
59282 | 1630 |
|
1631 |
\item |
|
69505 | 1632 |
The \<open>nonexhaustive\<close> option indicates that the functions are not |
56123
a27859b0ef7d
document the new 'nonexhaustive' option (cf. 52e8f110fec3)
blanchet
parents:
55945
diff
changeset
|
1633 |
necessarily specified for all constructors. It can be used to suppress the |
a27859b0ef7d
document the new 'nonexhaustive' option (cf. 52e8f110fec3)
blanchet
parents:
55945
diff
changeset
|
1634 |
warning that is normally emitted when some constructors are missing. |
59277 | 1635 |
|
1636 |
\item |
|
69505 | 1637 |
The \<open>transfer\<close> option indicates that an unconditional transfer rule |
1638 |
should be generated and proved \<open>by transfer_prover\<close>. The |
|
1639 |
\<open>[transfer_rule]\<close> attribute is set on the generated theorem. |
|
56123
a27859b0ef7d
document the new 'nonexhaustive' option (cf. 52e8f110fec3)
blanchet
parents:
55945
diff
changeset
|
1640 |
\end{itemize} |
a27859b0ef7d
document the new 'nonexhaustive' option (cf. 52e8f110fec3)
blanchet
parents:
55945
diff
changeset
|
1641 |
|
55460
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
1642 |
%%% TODO: elaborate on format of the equations |
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
1643 |
%%% TODO: elaborate on mutual and nested-to-mutual |
62081 | 1644 |
\<close> |
1645 |
||
1646 |
||
62731 | 1647 |
subsection \<open>Generated Theorems |
1648 |
\label{ssec:primrec-generated-theorems}\<close> |
|
52824 | 1649 |
|
59284 | 1650 |
(*<*) |
1651 |
context early |
|
1652 |
begin |
|
1653 |
(*>*) |
|
1654 |
||
62081 | 1655 |
text \<open> |
59284 | 1656 |
The @{command primrec} command generates the following properties (listed |
69597 | 1657 |
for \<^const>\<open>tfold\<close>): |
59284 | 1658 |
|
1659 |
\begin{indentblock} |
|
1660 |
\begin{description} |
|
1661 |
||
69505 | 1662 |
\item[\<open>f.\<close>\hthm{simps} \<open>[simp, code]\<close>\rm:] ~ \\ |
59284 | 1663 |
@{thm tfold.simps(1)[no_vars]} \\ |
1664 |
@{thm tfold.simps(2)[no_vars]} \\ |
|
69505 | 1665 |
The \<open>[code]\<close> attribute is set by the \<open>code\<close> plugin |
59284 | 1666 |
(Section~\ref{ssec:code-generator}). |
1667 |
||
69505 | 1668 |
\item[\<open>f.\<close>\hthm{transfer} \<open>[transfer_rule]\<close>\rm:] ~ \\ |
59284 | 1669 |
@{thm tfold.transfer[no_vars]} \\ |
69505 | 1670 |
This theorem is generated by the \<open>transfer\<close> plugin |
1671 |
(Section~\ref{ssec:transfer}) for functions declared with the \<open>transfer\<close> |
|
59284 | 1672 |
option enabled. |
1673 |
||
69505 | 1674 |
\item[\<open>f.\<close>\hthm{induct} \<open>[case_names C\<^sub>1 \<dots> C\<^sub>n]\<close>\rm:] ~ \\ |
59284 | 1675 |
This induction rule is generated for nested-as-mutual recursive functions |
1676 |
(Section~\ref{sssec:primrec-nested-as-mutual-recursion}). |
|
1677 |
||
69505 | 1678 |
\item[\<open>f\<^sub>1_\<dots>_f\<^sub>m.\<close>\hthm{induct} \<open>[case_names C\<^sub>1 \<dots> C\<^sub>n]\<close>\rm:] ~ \\ |
59284 | 1679 |
This induction rule is generated for nested-as-mutual recursive functions |
1680 |
(Section~\ref{sssec:primrec-nested-as-mutual-recursion}). Given $m > 1$ mutually |
|
1681 |
recursive functions, this rule can be used to prove $m$ properties |
|
1682 |
simultaneously. |
|
1683 |
||
1684 |
\end{description} |
|
1685 |
\end{indentblock} |
|
62081 | 1686 |
\<close> |
59284 | 1687 |
|
1688 |
(*<*) |
|
1689 |
end |
|
1690 |
(*>*) |
|
53619 | 1691 |
|
52824 | 1692 |
|
62731 | 1693 |
subsection \<open>Recursive Default Values for Selectors |
1694 |
\label{ssec:primrec-recursive-default-values-for-selectors}\<close> |
|
62081 | 1695 |
|
1696 |
text \<open> |
|
69505 | 1697 |
A datatype selector \<open>un_D\<close> can have a default value for each constructor |
52827 | 1698 |
on which it is not otherwise specified. Occasionally, it is useful to have the |
55354 | 1699 |
default value be defined recursively. This leads to a chicken-and-egg |
1700 |
situation, because the datatype is not introduced yet at the moment when the |
|
1701 |
selectors are introduced. Of course, we can always define the selectors |
|
1702 |
manually afterward, but we then have to state and prove all the characteristic |
|
1703 |
theorems ourselves instead of letting the package do it. |
|
1704 |
||
1705 |
Fortunately, there is a workaround that relies on overloading to relieve us |
|
1706 |
from the tedium of manual derivations: |
|
52827 | 1707 |
|
1708 |
\begin{enumerate} |
|
1709 |
\setlength{\itemsep}{0pt} |
|
1710 |
||
1711 |
\item |
|
69505 | 1712 |
Introduce a fully unspecified constant \<open>un_D\<^sub>0 :: 'a\<close> using |
58931 | 1713 |
@{command consts}. |
52827 | 1714 |
|
1715 |
\item |
|
69505 | 1716 |
Define the datatype, specifying \<open>un_D\<^sub>0\<close> as the selector's default |
53535 | 1717 |
value. |
52827 | 1718 |
|
1719 |
\item |
|
69505 | 1720 |
Define the behavior of \<open>un_D\<^sub>0\<close> on values of the newly introduced |
53535 | 1721 |
datatype using the \keyw{overloading} command. |
52827 | 1722 |
|
1723 |
\item |
|
69505 | 1724 |
Derive the desired equation on \<open>un_D\<close> from the characteristic equations |
1725 |
for \<open>un_D\<^sub>0\<close>. |
|
52827 | 1726 |
\end{enumerate} |
1727 |
||
53619 | 1728 |
\noindent |
52827 | 1729 |
The following example illustrates this procedure: |
62081 | 1730 |
\<close> |
52827 | 1731 |
|
57200
aab87ffa60cc
use 'where' clause for selector default value syntax
blanchet
parents:
57153
diff
changeset
|
1732 |
(*<*) |
aab87ffa60cc
use 'where' clause for selector default value syntax
blanchet
parents:
57153
diff
changeset
|
1733 |
hide_const termi |
aab87ffa60cc
use 'where' clause for selector default value syntax
blanchet
parents:
57153
diff
changeset
|
1734 |
(*>*) |
52827 | 1735 |
consts termi\<^sub>0 :: 'a |
1736 |
||
62731 | 1737 |
text \<open>\blankline\<close> |
53619 | 1738 |
|
58310 | 1739 |
datatype ('a, 'b) tlist = |
57200
aab87ffa60cc
use 'where' clause for selector default value syntax
blanchet
parents:
57153
diff
changeset
|
1740 |
TNil (termi: 'b) |
aab87ffa60cc
use 'where' clause for selector default value syntax
blanchet
parents:
57153
diff
changeset
|
1741 |
| TCons (thd: 'a) (ttl: "('a, 'b) tlist") |
aab87ffa60cc
use 'where' clause for selector default value syntax
blanchet
parents:
57153
diff
changeset
|
1742 |
where |
aab87ffa60cc
use 'where' clause for selector default value syntax
blanchet
parents:
57153
diff
changeset
|
1743 |
"ttl (TNil y) = TNil y" |
aab87ffa60cc
use 'where' clause for selector default value syntax
blanchet
parents:
57153
diff
changeset
|
1744 |
| "termi (TCons _ xs) = termi\<^sub>0 xs" |
52827 | 1745 |
|
62731 | 1746 |
text \<open>\blankline\<close> |
53619 | 1747 |
|
52827 | 1748 |
overloading |
61076 | 1749 |
termi\<^sub>0 \<equiv> "termi\<^sub>0 :: ('a, 'b) tlist \<Rightarrow> 'b" |
52827 | 1750 |
begin |
55530
3dfb724db099
renamed 'primrec_new' to 'primrec', overriding the old command (which it still uses as a fallback for old-style datatypes)
blanchet
parents:
55474
diff
changeset
|
1751 |
primrec termi\<^sub>0 :: "('a, 'b) tlist \<Rightarrow> 'b" where |
62081 | 1752 |
"termi\<^sub>0 (TNil y) = y" |
1753 |
| "termi\<^sub>0 (TCons x xs) = termi\<^sub>0 xs" |
|
52827 | 1754 |
end |
1755 |
||
62731 | 1756 |
text \<open>\blankline\<close> |
53619 | 1757 |
|
55354 | 1758 |
lemma termi_TCons[simp]: "termi (TCons x xs) = termi xs" |
60152 | 1759 |
by (cases xs) auto |
52827 | 1760 |
|
1761 |
||
62731 | 1762 |
subsection \<open>Compatibility Issues |
1763 |
\label{ssec:primrec-compatibility-issues}\<close> |
|
62081 | 1764 |
|
1765 |
text \<open> |
|
55530
3dfb724db099
renamed 'primrec_new' to 'primrec', overriding the old command (which it still uses as a fallback for old-style datatypes)
blanchet
parents:
55474
diff
changeset
|
1766 |
The command @{command primrec}'s behavior on new-style datatypes has been |
70820
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
1767 |
designed to be highly compatible with that for old, pre-Isabelle2015 datatypes, |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
1768 |
to ease migration. There is nonetheless at least one incompatibility that may |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
1769 |
arise when porting to the new package: |
53997 | 1770 |
|
1771 |
\begin{itemize} |
|
1772 |
\setlength{\itemsep}{0pt} |
|
1773 |
||
54185 | 1774 |
\item \emph{Some theorems have different names.} |
53997 | 1775 |
For $m > 1$ mutually recursive functions, |
69505 | 1776 |
\<open>f\<^sub>1_\<dots>_f\<^sub>m.simps\<close> has been broken down into separate |
1777 |
subcollections \<open>f\<^sub>i.simps\<close>. |
|
53997 | 1778 |
\end{itemize} |
62081 | 1779 |
\<close> |
1780 |
||
1781 |
||
62731 | 1782 |
section \<open>Defining Codatatypes |
1783 |
\label{sec:defining-codatatypes}\<close> |
|
62081 | 1784 |
|
1785 |
text \<open> |
|
53829 | 1786 |
Codatatypes can be specified using the @{command codatatype} command. The |
53623 | 1787 |
command is first illustrated through concrete examples featuring different |
1788 |
flavors of corecursion. More examples can be found in the directory |
|
63680 | 1789 |
\<^dir>\<open>~~/src/HOL/Datatype_Examples\<close>. The \emph{Archive of Formal Proofs} also |
76987 | 1790 |
includes some useful codatatypes, notably for lazy lists \<^cite>\<open>"lochbihler-2010"\<close>. |
62081 | 1791 |
\<close> |
1792 |
||
1793 |
||
62731 | 1794 |
subsection \<open>Introductory Examples |
1795 |
\label{ssec:codatatype-introductory-examples}\<close> |
|
1796 |
||
1797 |
subsubsection \<open>Simple Corecursion |
|
1798 |
\label{sssec:codatatype-simple-corecursion}\<close> |
|
62081 | 1799 |
|
1800 |
text \<open> |
|
57542 | 1801 |
Non-corecursive codatatypes coincide with the corresponding datatypes, so they |
56947 | 1802 |
are rarely used in practice. \emph{Corecursive codatatypes} have the same syntax |
53623 | 1803 |
as recursive datatypes, except for the command name. For example, here is the |
1804 |
definition of lazy lists: |
|
62081 | 1805 |
\<close> |
53623 | 1806 |
|
57206
d9be905d6283
changed syntax of map: and rel: arguments to BNF-based datatypes
blanchet
parents:
57200
diff
changeset
|
1807 |
codatatype (lset: 'a) llist = |
57200
aab87ffa60cc
use 'where' clause for selector default value syntax
blanchet
parents:
57153
diff
changeset
|
1808 |
lnull: LNil |
53623 | 1809 |
| LCons (lhd: 'a) (ltl: "'a llist") |
57206
d9be905d6283
changed syntax of map: and rel: arguments to BNF-based datatypes
blanchet
parents:
57200
diff
changeset
|
1810 |
for |
d9be905d6283
changed syntax of map: and rel: arguments to BNF-based datatypes
blanchet
parents:
57200
diff
changeset
|
1811 |
map: lmap |
d9be905d6283
changed syntax of map: and rel: arguments to BNF-based datatypes
blanchet
parents:
57200
diff
changeset
|
1812 |
rel: llist_all2 |
62330 | 1813 |
pred: llist_all |
57200
aab87ffa60cc
use 'where' clause for selector default value syntax
blanchet
parents:
57153
diff
changeset
|
1814 |
where |
aab87ffa60cc
use 'where' clause for selector default value syntax
blanchet
parents:
57153
diff
changeset
|
1815 |
"ltl LNil = LNil" |
53623 | 1816 |
|
62081 | 1817 |
text \<open> |
53623 | 1818 |
\noindent |
69505 | 1819 |
Lazy lists can be infinite, such as \<open>LCons 0 (LCons 0 (\<dots>))\<close> and |
1820 |
\<open>LCons 0 (LCons 1 (LCons 2 (\<dots>)))\<close>. Here is a related type, that of |
|
53647 | 1821 |
infinite streams: |
62081 | 1822 |
\<close> |
53647 | 1823 |
|
57206
d9be905d6283
changed syntax of map: and rel: arguments to BNF-based datatypes
blanchet
parents:
57200
diff
changeset
|
1824 |
codatatype (sset: 'a) stream = |
53647 | 1825 |
SCons (shd: 'a) (stl: "'a stream") |
57206
d9be905d6283
changed syntax of map: and rel: arguments to BNF-based datatypes
blanchet
parents:
57200
diff
changeset
|
1826 |
for |
d9be905d6283
changed syntax of map: and rel: arguments to BNF-based datatypes
blanchet
parents:
57200
diff
changeset
|
1827 |
map: smap |
d9be905d6283
changed syntax of map: and rel: arguments to BNF-based datatypes
blanchet
parents:
57200
diff
changeset
|
1828 |
rel: stream_all2 |
53647 | 1829 |
|
62081 | 1830 |
text \<open> |
53647 | 1831 |
\noindent |
1832 |
Another interesting type that can |
|
53623 | 1833 |
be defined as a codatatype is that of the extended natural numbers: |
62081 | 1834 |
\<close> |
53623 | 1835 |
|
58245 | 1836 |
codatatype enat = EZero | ESucc enat |
53623 | 1837 |
|
62081 | 1838 |
text \<open> |
53623 | 1839 |
\noindent |
69505 | 1840 |
This type has exactly one infinite element, \<open>ESucc (ESucc (ESucc (\<dots>)))\<close>, |
53623 | 1841 |
that represents $\infty$. In addition, it has finite values of the form |
69505 | 1842 |
\<open>ESucc (\<dots> (ESucc EZero)\<dots>)\<close>. |
53675 | 1843 |
|
1844 |
Here is an example with many constructors: |
|
62081 | 1845 |
\<close> |
53623 | 1846 |
|
53675 | 1847 |
codatatype 'a process = |
1848 |
Fail |
|
1849 |
| Skip (cont: "'a process") |
|
1850 |
| Action (prefix: 'a) (cont: "'a process") |
|
1851 |
| Choice (left: "'a process") (right: "'a process") |
|
1852 |
||
62081 | 1853 |
text \<open> |
53829 | 1854 |
\noindent |
69597 | 1855 |
Notice that the \<^const>\<open>cont\<close> selector is associated with both \<^const>\<open>Skip\<close> |
1856 |
and \<^const>\<open>Action\<close>. |
|
62081 | 1857 |
\<close> |
1858 |
||
1859 |
||
62731 | 1860 |
subsubsection \<open>Mutual Corecursion |
1861 |
\label{sssec:codatatype-mutual-corecursion}\<close> |
|
62081 | 1862 |
|
1863 |
text \<open> |
|
53623 | 1864 |
\noindent |
1865 |
The example below introduces a pair of \emph{mutually corecursive} types: |
|
62081 | 1866 |
\<close> |
53623 | 1867 |
|
58245 | 1868 |
codatatype even_enat = Even_EZero | Even_ESucc odd_enat |
1869 |
and odd_enat = Odd_ESucc even_enat |
|
53623 | 1870 |
|
1871 |
||
62731 | 1872 |
subsubsection \<open>Nested Corecursion |
1873 |
\label{sssec:codatatype-nested-corecursion}\<close> |
|
62081 | 1874 |
|
1875 |
text \<open> |
|
53623 | 1876 |
\noindent |
53675 | 1877 |
The next examples feature \emph{nested corecursion}: |
62081 | 1878 |
\<close> |
53623 | 1879 |
|
53644 | 1880 |
codatatype 'a tree\<^sub>i\<^sub>i = Node\<^sub>i\<^sub>i (lbl\<^sub>i\<^sub>i: 'a) (sub\<^sub>i\<^sub>i: "'a tree\<^sub>i\<^sub>i llist") |
53675 | 1881 |
|
62731 | 1882 |
text \<open>\blankline\<close> |
53752 | 1883 |
|
53644 | 1884 |
codatatype 'a tree\<^sub>i\<^sub>s = Node\<^sub>i\<^sub>s (lbl\<^sub>i\<^sub>s: 'a) (sub\<^sub>i\<^sub>s: "'a tree\<^sub>i\<^sub>s fset") |
52805 | 1885 |
|
62731 | 1886 |
text \<open>\blankline\<close> |
53752 | 1887 |
|
55350 | 1888 |
codatatype 'a sm = SM (accept: bool) (trans: "'a \<Rightarrow> 'a sm") |
53675 | 1889 |
|
52824 | 1890 |
|
62731 | 1891 |
subsection \<open>Command Syntax |
1892 |
\label{ssec:codatatype-command-syntax}\<close> |
|
1893 |
||
1894 |
subsubsection \<open>\keyw{codatatype} |
|
1895 |
\label{sssec:codatatype}\<close> |
|
62081 | 1896 |
|
1897 |
text \<open> |
|
53829 | 1898 |
\begin{matharray}{rcl} |
69505 | 1899 |
@{command_def "codatatype"} & : & \<open>local_theory \<rightarrow> local_theory\<close> |
53829 | 1900 |
\end{matharray} |
1901 |
||
69597 | 1902 |
\<^rail>\<open> |
59282 | 1903 |
@@{command codatatype} target? @{syntax dt_options}? @{syntax dt_spec} |
69597 | 1904 |
\<close> |
53829 | 1905 |
|
55351 | 1906 |
\medskip |
1907 |
||
53829 | 1908 |
\noindent |
52827 | 1909 |
Definitions of codatatypes have almost exactly the same syntax as for datatypes |
69505 | 1910 |
(Section~\ref{ssec:datatype-command-syntax}). The \<open>discs_sels\<close> option |
57094
589ec121ce1a
don't generate discriminators and selectors for 'datatype_new' unless the user asked for it
blanchet
parents:
57092
diff
changeset
|
1911 |
is superfluous because discriminators and selectors are always generated for |
589ec121ce1a
don't generate discriminators and selectors for 'datatype_new' unless the user asked for it
blanchet
parents:
57092
diff
changeset
|
1912 |
codatatypes. |
62081 | 1913 |
\<close> |
1914 |
||
1915 |
||
62731 | 1916 |
subsection \<open>Generated Constants |
1917 |
\label{ssec:codatatype-generated-constants}\<close> |
|
62081 | 1918 |
|
1919 |
text \<open> |
|
69505 | 1920 |
Given a codatatype \<open>('a\<^sub>1, \<dots>, 'a\<^sub>m) t\<close> |
1921 |
with $m > 0$ live type variables and $n$ constructors \<open>t.C\<^sub>1\<close>, |
|
1922 |
\ldots, \<open>t.C\<^sub>n\<close>, the same auxiliary constants are generated as for |
|
53623 | 1923 |
datatypes (Section~\ref{ssec:datatype-generated-constants}), except that the |
58190 | 1924 |
recursor is replaced by a dual concept: |
53623 | 1925 |
|
55354 | 1926 |
\medskip |
1927 |
||
1928 |
\begin{tabular}{@ {}ll@ {}} |
|
1929 |
Corecursor: & |
|
69505 | 1930 |
\<open>t.corec_t\<close> |
55354 | 1931 |
\end{tabular} |
62081 | 1932 |
\<close> |
1933 |
||
1934 |
||
62731 | 1935 |
subsection \<open>Generated Theorems |
1936 |
\label{ssec:codatatype-generated-theorems}\<close> |
|
62081 | 1937 |
|
1938 |
text \<open> |
|
53829 | 1939 |
The characteristic theorems generated by @{command codatatype} are grouped in |
53623 | 1940 |
three broad categories: |
1941 |
||
1942 |
\begin{itemize} |
|
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
1943 |
\setlength{\itemsep}{0pt} |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
1944 |
|
56655 | 1945 |
\item The \emph{free constructor theorems} |
1946 |
(Section~\ref{sssec:free-constructor-theorems}) are properties of the |
|
1947 |
constructors and destructors that can be derived for any freely generated type. |
|
1948 |
||
1949 |
\item The \emph{functorial theorems} |
|
1950 |
(Section~\ref{sssec:functorial-theorems}) are properties of datatypes related to |
|
53623 | 1951 |
their BNF nature. |
1952 |
||
56655 | 1953 |
\item The \emph{coinductive theorems} (Section~\ref{sssec:coinductive-theorems}) |
1954 |
are properties of datatypes related to their coinductive nature. |
|
53623 | 1955 |
\end{itemize} |
1956 |
||
1957 |
\noindent |
|
56655 | 1958 |
The first two categories are exactly as for datatypes. |
62081 | 1959 |
\<close> |
1960 |
||
1961 |
||
62731 | 1962 |
subsubsection \<open>Coinductive Theorems |
1963 |
\label{sssec:coinductive-theorems}\<close> |
|
62081 | 1964 |
|
1965 |
text \<open> |
|
69597 | 1966 |
The coinductive theorems are listed below for \<^typ>\<open>'a llist\<close>: |
53623 | 1967 |
|
1968 |
\begin{indentblock} |
|
1969 |
\begin{description} |
|
1970 |
||
53643 | 1971 |
\item[\begin{tabular}{@ {}l@ {}} |
69505 | 1972 |
\<open>t.\<close>\hthm{coinduct} \<open>[consumes m, case_names t\<^sub>1 \<dots> t\<^sub>m,\<close> \\ |
1973 |
\phantom{\<open>t.\<close>\hthm{coinduct} \<open>[\<close>}\<open>case_conclusion D\<^sub>1 \<dots> |
|
1974 |
D\<^sub>n, coinduct t]\<close>\rm: |
|
53643 | 1975 |
\end{tabular}] ~ \\ |
53623 | 1976 |
@{thm llist.coinduct[no_vars]} |
53617 | 1977 |
|
53643 | 1978 |
\item[\begin{tabular}{@ {}l@ {}} |
69505 | 1979 |
\<open>t.\<close>\hthm{coinduct_strong} \<open>[consumes m, case_names t\<^sub>1 \<dots> t\<^sub>m,\<close> \\ |
1980 |
\phantom{\<open>t.\<close>\hthm{coinduct_strong} \<open>[\<close>}\<open>case_conclusion D\<^sub>1 \<dots> D\<^sub>n]\<close>\rm: |
|
53643 | 1981 |
\end{tabular}] ~ \\ |
57983
6edc3529bb4e
reordered some (co)datatype property names for more consistency
blanchet
parents:
57982
diff
changeset
|
1982 |
@{thm llist.coinduct_strong[no_vars]} |
53617 | 1983 |
|
53643 | 1984 |
\item[\begin{tabular}{@ {}l@ {}} |
69505 | 1985 |
\<open>t.\<close>\hthm{rel_coinduct} \<open>[consumes m, case_names t\<^sub>1 \<dots> t\<^sub>m,\<close> \\ |
1986 |
\phantom{\<open>t.\<close>\hthm{rel_coinduct} \<open>[\<close>}\<open>case_conclusion D\<^sub>1 \<dots> |
|
1987 |
D\<^sub>n, coinduct pred]\<close>\rm: |
|
57304 | 1988 |
\end{tabular}] ~ \\ |
1989 |
@{thm llist.rel_coinduct[no_vars]} |
|
1990 |
||
1991 |
\item[\begin{tabular}{@ {}l@ {}} |
|
69505 | 1992 |
\<open>t\<^sub>1_\<dots>_t\<^sub>m.\<close>\hthm{coinduct} \<open>[case_names t\<^sub>1 \<dots> t\<^sub>m, case_conclusion D\<^sub>1 \<dots> D\<^sub>n]\<close> \\ |
1993 |
\<open>t\<^sub>1_\<dots>_t\<^sub>m.\<close>\hthm{coinduct_strong} \<open>[case_names t\<^sub>1 \<dots> t\<^sub>m,\<close> \\ |
|
1994 |
\phantom{\<open>t\<^sub>1_\<dots>_t\<^sub>m.\<close>\hthm{coinduct_strong} \<open>[\<close>}\<open>case_conclusion D\<^sub>1 \<dots> D\<^sub>n]\<close>\rm: \\ |
|
1995 |
\<open>t\<^sub>1_\<dots>_t\<^sub>m.\<close>\hthm{rel_coinduct} \<open>[case_names t\<^sub>1 \<dots> t\<^sub>m,\<close> \\ |
|
1996 |
\phantom{\<open>t\<^sub>1_\<dots>_t\<^sub>m.\<close>\hthm{rel_coinduct} \<open>[\<close>}\<open>case_conclusion D\<^sub>1 \<dots> D\<^sub>n]\<close>\rm: \\ |
|
53643 | 1997 |
\end{tabular}] ~ \\ |
1998 |
Given $m > 1$ mutually corecursive codatatypes, these coinduction rules can be |
|
1999 |
used to prove $m$ properties simultaneously. |
|
2000 |
||
57701 | 2001 |
\item[\begin{tabular}{@ {}l@ {}} |
69505 | 2002 |
\<open>t\<^sub>1_\<dots>_t\<^sub>m.\<close>\hthm{set_induct} \<open>[case_names C\<^sub>1 \<dots> C\<^sub>n,\<close> \\ |
2003 |
\phantom{\<open>t\<^sub>1_\<dots>_t\<^sub>m.\<close>\hthm{set_induct} \<open>[\<close>}\<open>induct set: set\<^sub>j_t\<^sub>1, \<dots>, induct set: set\<^sub>j_t\<^sub>m]\<close>\rm: \\ |
|
57701 | 2004 |
\end{tabular}] ~ \\ |
2005 |
@{thm llist.set_induct[no_vars]} \\ |
|
69505 | 2006 |
If $m = 1$, the attribute \<open>[consumes 1]\<close> is generated as well. |
2007 |
||
2008 |
\item[\<open>t.\<close>\hthm{corec}\rm:] ~ \\ |
|
53623 | 2009 |
@{thm llist.corec(1)[no_vars]} \\ |
2010 |
@{thm llist.corec(2)[no_vars]} |
|
2011 |
||
69505 | 2012 |
\item[\<open>t.\<close>\hthm{corec_code} \<open>[code]\<close>\rm:] ~ \\ |
58335
a5a3b576fcfb
generate 'code' attribute only if 'code' plugin is enabled
blanchet
parents:
58311
diff
changeset
|
2013 |
@{thm llist.corec_code[no_vars]} \\ |
69505 | 2014 |
The \<open>[code]\<close> attribute is set by the \<open>code\<close> plugin |
59284 | 2015 |
(Section~\ref{ssec:code-generator}). |
57490 | 2016 |
|
69505 | 2017 |
\item[\<open>t.\<close>\hthm{corec_disc}\rm:] ~ \\ |
57983
6edc3529bb4e
reordered some (co)datatype property names for more consistency
blanchet
parents:
57982
diff
changeset
|
2018 |
@{thm llist.corec_disc(1)[no_vars]} \\ |
6edc3529bb4e
reordered some (co)datatype property names for more consistency
blanchet
parents:
57982
diff
changeset
|
2019 |
@{thm llist.corec_disc(2)[no_vars]} |
6edc3529bb4e
reordered some (co)datatype property names for more consistency
blanchet
parents:
57982
diff
changeset
|
2020 |
|
69505 | 2021 |
\item[\<open>t.\<close>\hthm{corec_disc_iff} \<open>[simp]\<close>\rm:] ~ \\ |
57983
6edc3529bb4e
reordered some (co)datatype property names for more consistency
blanchet
parents:
57982
diff
changeset
|
2022 |
@{thm llist.corec_disc_iff(1)[no_vars]} \\ |
6edc3529bb4e
reordered some (co)datatype property names for more consistency
blanchet
parents:
57982
diff
changeset
|
2023 |
@{thm llist.corec_disc_iff(2)[no_vars]} |
6edc3529bb4e
reordered some (co)datatype property names for more consistency
blanchet
parents:
57982
diff
changeset
|
2024 |
|
69505 | 2025 |
\item[\<open>t.\<close>\hthm{corec_sel} \<open>[simp]\<close>\rm:] ~ \\ |
57983
6edc3529bb4e
reordered some (co)datatype property names for more consistency
blanchet
parents:
57982
diff
changeset
|
2026 |
@{thm llist.corec_sel(1)[no_vars]} \\ |
6edc3529bb4e
reordered some (co)datatype property names for more consistency
blanchet
parents:
57982
diff
changeset
|
2027 |
@{thm llist.corec_sel(2)[no_vars]} |
53643 | 2028 |
|
69505 | 2029 |
\item[\<open>t.\<close>\hthm{map_o_corec}\rm:] ~ \\ |
58735 | 2030 |
@{thm llist.map_o_corec[no_vars]} |
2031 |
||
69505 | 2032 |
\item[\<open>t.\<close>\hthm{corec_transfer} \<open>[transfer_rule]\<close>\rm:] ~ \\ |
58915 | 2033 |
@{thm llist.corec_transfer[no_vars]} \\ |
69505 | 2034 |
The \<open>[transfer_rule]\<close> attribute is set by the \<open>transfer\<close> plugin |
59824 | 2035 |
(Section~\ref{ssec:transfer}) for type constructors with no dead type arguments. |
58449 | 2036 |
|
53623 | 2037 |
\end{description} |
2038 |
\end{indentblock} |
|
2039 |
||
2040 |
\noindent |
|
53829 | 2041 |
For convenience, @{command codatatype} also provides the following collection: |
53623 | 2042 |
|
2043 |
\begin{indentblock} |
|
2044 |
\begin{description} |
|
2045 |
||
69505 | 2046 |
\item[\<open>t.\<close>\hthm{simps}] = \<open>t.inject\<close> \<open>t.distinct\<close> \<open>t.case\<close> \<open>t.corec_disc_iff\<close> \<open>t.corec_sel\<close> \\ |
2047 |
\<open>t.map\<close> \<open>t.rel_inject\<close> \<open>t.rel_distinct\<close> \<open>t.set\<close> |
|
53623 | 2048 |
|
2049 |
\end{description} |
|
2050 |
\end{indentblock} |
|
62081 | 2051 |
\<close> |
2052 |
||
2053 |
||
70820
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
2054 |
subsection \<open>Antiquotation |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
2055 |
\label{ssec:codatatype-antiquotation}\<close> |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
2056 |
|
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
2057 |
subsubsection \<open>\textit{codatatype} |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
2058 |
\label{sssec:codatatype-codatatype}\<close> |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
2059 |
|
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
2060 |
text \<open> |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
2061 |
The \textit{codatatype} antiquotation, written |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
2062 |
\texttt{\char`\\\char`<\char`^}\verb|codatatype>|\guilsinglleft\textit{t}\guilsinglright{} |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
2063 |
or \texttt{@}\verb|{codatatype| \textit{t}\verb|}|, where \textit{t} is a type |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
2064 |
name, expands to \LaTeX{} code for the definition of the codatatype, with each |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
2065 |
constructor listed with its argument types. For example, if \textit{t} is |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
2066 |
@{type llist}: |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
2067 |
|
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
2068 |
\begin{quote} |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
2069 |
\<^codatatype>\<open>llist\<close> |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
2070 |
\end{quote} |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
2071 |
\<close> |
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
2072 |
|
77c8b8e73f88
document antiquotations + clarify porting text slightly
blanchet
parents:
70818
diff
changeset
|
2073 |
|
62731 | 2074 |
section \<open>Defining Primitively Corecursive Functions |
2075 |
\label{sec:defining-primitively-corecursive-functions}\<close> |
|
62081 | 2076 |
|
2077 |
text \<open> |
|
54183 | 2078 |
Corecursive functions can be specified using the @{command primcorec} and |
61788 | 2079 |
\keyw{prim\-corec\-ursive} commands, which support primitive corecursion. |
2080 |
Other approaches include the more general \keyw{partial_function} command, the |
|
62756 | 2081 |
\keyw{corec} and \keyw{corecursive} commands, and techniques based on domains |
76987 | 2082 |
and topologies \<^cite>\<open>"lochbihler-hoelzl-2014"\<close>. In this tutorial, the focus is |
62756 | 2083 |
on @{command primcorec} and @{command primcorecursive}; \keyw{corec} and |
2084 |
\keyw{corecursive} are described in a separate tutorial |
|
76987 | 2085 |
\<^cite>\<open>"isabelle-corec"\<close>. More examples can be found in the directories |
63680 | 2086 |
\<^dir>\<open>~~/src/HOL/Datatype_Examples\<close> and \<^dir>\<open>~~/src/HOL/Corec_Examples\<close>. |
53644 | 2087 |
|
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2088 |
Whereas recursive functions consume datatypes one constructor at a time, |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2089 |
corecursive functions construct codatatypes one constructor at a time. |
53752 | 2090 |
Partly reflecting a lack of agreement among proponents of coalgebraic methods, |
2091 |
Isabelle supports three competing syntaxes for specifying a function $f$: |
|
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2092 |
|
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2093 |
\begin{itemize} |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2094 |
\setlength{\itemsep}{0pt} |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2095 |
|
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2096 |
\abovedisplayskip=.5\abovedisplayskip |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2097 |
\belowdisplayskip=.5\belowdisplayskip |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2098 |
|
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2099 |
\item The \emph{destructor view} specifies $f$ by implications of the form |
69505 | 2100 |
\[\<open>\<dots> \<Longrightarrow> is_C\<^sub>j (f x\<^sub>1 \<dots> x\<^sub>n)\<close>\] and |
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2101 |
equations of the form |
69505 | 2102 |
\[\<open>un_C\<^sub>ji (f x\<^sub>1 \<dots> x\<^sub>n) = \<dots>\<close>\] |
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2103 |
This style is popular in the coalgebraic literature. |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2104 |
|
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2105 |
\item The \emph{constructor view} specifies $f$ by equations of the form |
69505 | 2106 |
\[\<open>\<dots> \<Longrightarrow> f x\<^sub>1 \<dots> x\<^sub>n = C\<^sub>j \<dots>\<close>\] |
53752 | 2107 |
This style is often more concise than the previous one. |
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2108 |
|
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2109 |
\item The \emph{code view} specifies $f$ by a single equation of the form |
69505 | 2110 |
\[\<open>f x\<^sub>1 \<dots> x\<^sub>n = \<dots>\<close>\] |
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2111 |
with restrictions on the format of the right-hand side. Lazy functional |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2112 |
programming languages such as Haskell support a generalized version of this |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2113 |
style. |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2114 |
\end{itemize} |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2115 |
|
53753
ae7f50e70c09
renamed "primcorec" to "primcorecursive", to open the door to a 'theory -> theory' command called "primcorec" (cf. "fun" vs. "function")
blanchet
parents:
53752
diff
changeset
|
2116 |
All three styles are available as input syntax. Whichever syntax is chosen, |
ae7f50e70c09
renamed "primcorec" to "primcorecursive", to open the door to a 'theory -> theory' command called "primcorec" (cf. "fun" vs. "function")
blanchet
parents:
53752
diff
changeset
|
2117 |
characteristic theorems for all three styles are generated. |
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2118 |
|
52828 | 2119 |
%%% TODO: partial_function? E.g. for defining tail recursive function on lazy |
2120 |
%%% lists (cf. terminal0 in TLList.thy) |
|
62081 | 2121 |
\<close> |
2122 |
||
2123 |
||
62731 | 2124 |
subsection \<open>Introductory Examples |
2125 |
\label{ssec:primcorec-introductory-examples}\<close> |
|
62081 | 2126 |
|
2127 |
text \<open> |
|
53646 | 2128 |
Primitive corecursion is illustrated through concrete examples based on the |
2129 |
codatatypes defined in Section~\ref{ssec:codatatype-introductory-examples}. More |
|
63680 | 2130 |
examples can be found in the directory \<^dir>\<open>~~/src/HOL/Datatype_Examples\<close>. |
61304 | 2131 |
The code view is favored in the examples below. Sections |
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2132 |
\ref{ssec:primrec-constructor-view} and \ref{ssec:primrec-destructor-view} |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2133 |
present the same examples expressed using the constructor and destructor views. |
62081 | 2134 |
\<close> |
2135 |
||
2136 |
||
62731 | 2137 |
subsubsection \<open>Simple Corecursion |
2138 |
\label{sssec:primcorec-simple-corecursion}\<close> |
|
62081 | 2139 |
|
2140 |
text \<open> |
|
53752 | 2141 |
Following the code view, corecursive calls are allowed on the right-hand side as |
2142 |
long as they occur under a constructor, which itself appears either directly to |
|
2143 |
the right of the equal sign or in a conditional expression: |
|
62081 | 2144 |
\<close> |
53646 | 2145 |
|
59284 | 2146 |
primcorec (*<*)(transfer) (*>*)literate :: "('a \<Rightarrow> 'a) \<Rightarrow> 'a \<Rightarrow> 'a llist" where |
54072 | 2147 |
"literate g x = LCons x (literate g (g x))" |
53647 | 2148 |
|
62731 | 2149 |
text \<open>\blankline\<close> |
53677 | 2150 |
|
53826 | 2151 |
primcorec siterate :: "('a \<Rightarrow> 'a) \<Rightarrow> 'a \<Rightarrow> 'a stream" where |
54072 | 2152 |
"siterate g x = SCons x (siterate g (g x))" |
53644 | 2153 |
|
62081 | 2154 |
text \<open> |
53646 | 2155 |
\noindent |
2156 |
The constructor ensures that progress is made---i.e., the function is |
|
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2157 |
\emph{productive}. The above functions compute the infinite lazy list or stream |
69505 | 2158 |
\<open>[x, g x, g (g x), \<dots>]\<close>. Productivity guarantees that prefixes |
2159 |
\<open>[x, g x, g (g x), \<dots>, (g ^^ k) x]\<close> of arbitrary finite length |
|
2160 |
\<open>k\<close> can be computed by unfolding the code equation a finite number of |
|
53863
c7364dca96f2
textual improvements following Christian Sternagel's feedback
blanchet
parents:
53857
diff
changeset
|
2161 |
times. |
53646 | 2162 |
|
53752 | 2163 |
Corecursive functions construct codatatype values, but nothing prevents them |
53863
c7364dca96f2
textual improvements following Christian Sternagel's feedback
blanchet
parents:
53857
diff
changeset
|
2164 |
from also consuming such values. The following function drops every second |
53675 | 2165 |
element in a stream: |
62081 | 2166 |
\<close> |
53675 | 2167 |
|
53826 | 2168 |
primcorec every_snd :: "'a stream \<Rightarrow> 'a stream" where |
53675 | 2169 |
"every_snd s = SCons (shd s) (stl (stl s))" |
2170 |
||
62081 | 2171 |
text \<open> |
53752 | 2172 |
\noindent |
69505 | 2173 |
Constructs such as \<open>let\<close>--\<open>in\<close>, \<open>if\<close>--\<open>then\<close>--\<open>else\<close>, and \<open>case\<close>--\<open>of\<close> may |
53646 | 2174 |
appear around constructors that guard corecursive calls: |
62081 | 2175 |
\<close> |
2176 |
||
2177 |
primcorec lapp :: "'a llist \<Rightarrow> 'a llist \<Rightarrow> 'a llist" where |
|
2178 |
"lapp xs ys = |
|
53644 | 2179 |
(case xs of |
2180 |
LNil \<Rightarrow> ys |
|
62081 | 2181 |
| LCons x xs' \<Rightarrow> LCons x (lapp xs' ys))" |
2182 |
||
2183 |
text \<open> |
|
53752 | 2184 |
\noindent |
69505 | 2185 |
For technical reasons, \<open>case\<close>--\<open>of\<close> is only supported for |
62317 | 2186 |
case distinctions on (co)datatypes that provide discriminators and selectors. |
2187 |
||
54402 | 2188 |
Pattern matching is not supported by @{command primcorec}. Fortunately, it is |
62081 | 2189 |
easy to generate pattern-maching equations using the @{command simps_of_case} |
63680 | 2190 |
command provided by the theory \<^file>\<open>~~/src/HOL/Library/Simps_Case_Conv.thy\<close>. |
62081 | 2191 |
\<close> |
2192 |
||
2193 |
simps_of_case lapp_simps: lapp.code |
|
2194 |
||
2195 |
text \<open> |
|
2196 |
This generates the lemma collection @{thm [source] lapp_simps}: |
|
54402 | 2197 |
% |
62081 | 2198 |
\begin{gather*} |
2199 |
@{thm lapp_simps(1)[no_vars]} \\ |
|
2200 |
@{thm lapp_simps(2)[no_vars]} |
|
2201 |
\end{gather*} |
|
54402 | 2202 |
% |
53646 | 2203 |
Corecursion is useful to specify not only functions but also infinite objects: |
62081 | 2204 |
\<close> |
53646 | 2205 |
|
53826 | 2206 |
primcorec infty :: enat where |
58245 | 2207 |
"infty = ESucc infty" |
53644 | 2208 |
|
62081 | 2209 |
text \<open> |
53752 | 2210 |
\noindent |
2211 |
The example below constructs a pseudorandom process value. It takes a stream of |
|
69505 | 2212 |
actions (\<open>s\<close>), a pseudorandom function generator (\<open>f\<close>), and a |
2213 |
pseudorandom seed (\<open>n\<close>): |
|
62081 | 2214 |
\<close> |
53675 | 2215 |
|
59861 | 2216 |
(*<*) |
2217 |
context early |
|
2218 |
begin |
|
2219 |
(*>*) |
|
2220 |
primcorec |
|
53752 | 2221 |
random_process :: "'a stream \<Rightarrow> (int \<Rightarrow> int) \<Rightarrow> int \<Rightarrow> 'a process" |
2222 |
where |
|
53675 | 2223 |
"random_process s f n = |
2224 |
(if n mod 4 = 0 then |
|
2225 |
Fail |
|
2226 |
else if n mod 4 = 1 then |
|
2227 |
Skip (random_process s f (f n)) |
|
2228 |
else if n mod 4 = 2 then |
|
2229 |
Action (shd s) (random_process (stl s) f (f n)) |
|
2230 |
else |
|
2231 |
Choice (random_process (every_snd s) (f \<circ> f) (f n)) |
|
2232 |
(random_process (every_snd (stl s)) (f \<circ> f) (f (f n))))" |
|
59861 | 2233 |
(*<*) |
2234 |
end |
|
2235 |
(*>*) |
|
53675 | 2236 |
|
62081 | 2237 |
text \<open> |
53675 | 2238 |
\noindent |
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2239 |
The main disadvantage of the code view is that the conditions are tested |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2240 |
sequentially. This is visible in the generated theorems. The constructor and |
53752 | 2241 |
destructor views offer nonsequential alternatives. |
62081 | 2242 |
\<close> |
2243 |
||
2244 |
||
62731 | 2245 |
subsubsection \<open>Mutual Corecursion |
2246 |
\label{sssec:primcorec-mutual-corecursion}\<close> |
|
62081 | 2247 |
|
2248 |
text \<open> |
|
53647 | 2249 |
The syntax for mutually corecursive functions over mutually corecursive |
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2250 |
datatypes is unsurprising: |
62081 | 2251 |
\<close> |
53647 | 2252 |
|
53826 | 2253 |
primcorec |
53644 | 2254 |
even_infty :: even_enat and |
2255 |
odd_infty :: odd_enat |
|
2256 |
where |
|
62081 | 2257 |
"even_infty = Even_ESucc odd_infty" |
2258 |
| "odd_infty = Odd_ESucc even_infty" |
|
2259 |
||
2260 |
||
62731 | 2261 |
subsubsection \<open>Nested Corecursion |
2262 |
\label{sssec:primcorec-nested-corecursion}\<close> |
|
62081 | 2263 |
|
2264 |
text \<open> |
|
69597 | 2265 |
The next pair of examples generalize the \<^const>\<open>literate\<close> and \<^const>\<open>siterate\<close> |
53647 | 2266 |
functions (Section~\ref{sssec:primcorec-nested-corecursion}) to possibly |
69505 | 2267 |
infinite trees in which subnodes are organized either as a lazy list (\<open>tree\<^sub>i\<^sub>i\<close>) or as a finite set (\<open>tree\<^sub>i\<^sub>s\<close>). They rely on the map functions of |
54072 | 2268 |
the nesting type constructors to lift the corecursive calls: |
62081 | 2269 |
\<close> |
53647 | 2270 |
|
53826 | 2271 |
primcorec iterate\<^sub>i\<^sub>i :: "('a \<Rightarrow> 'a llist) \<Rightarrow> 'a \<Rightarrow> 'a tree\<^sub>i\<^sub>i" where |
54072 | 2272 |
"iterate\<^sub>i\<^sub>i g x = Node\<^sub>i\<^sub>i x (lmap (iterate\<^sub>i\<^sub>i g) (g x))" |
53644 | 2273 |
|
62731 | 2274 |
text \<open>\blankline\<close> |
53677 | 2275 |
|
53826 | 2276 |
primcorec iterate\<^sub>i\<^sub>s :: "('a \<Rightarrow> 'a fset) \<Rightarrow> 'a \<Rightarrow> 'a tree\<^sub>i\<^sub>s" where |
54072 | 2277 |
"iterate\<^sub>i\<^sub>s g x = Node\<^sub>i\<^sub>s x (fimage (iterate\<^sub>i\<^sub>s g) (g x))" |
53644 | 2278 |
|
62081 | 2279 |
text \<open> |
53752 | 2280 |
\noindent |
54072 | 2281 |
Both examples follow the usual format for constructor arguments associated |
2282 |
with nested recursive occurrences of the datatype. Consider |
|
69597 | 2283 |
\<^const>\<open>iterate\<^sub>i\<^sub>i\<close>. The term \<^term>\<open>g x\<close> constructs an \<^typ>\<open>'a llist\<close> |
2284 |
value, which is turned into an \<^typ>\<open>'a tree\<^sub>i\<^sub>i llist\<close> value using |
|
2285 |
\<^const>\<open>lmap\<close>. |
|
54072 | 2286 |
|
2287 |
This format may sometimes feel artificial. The following function constructs |
|
2288 |
a tree with a single, infinite branch from a stream: |
|
62081 | 2289 |
\<close> |
54072 | 2290 |
|
2291 |
primcorec tree\<^sub>i\<^sub>i_of_stream :: "'a stream \<Rightarrow> 'a tree\<^sub>i\<^sub>i" where |
|
2292 |
"tree\<^sub>i\<^sub>i_of_stream s = |
|
2293 |
Node\<^sub>i\<^sub>i (shd s) (lmap tree\<^sub>i\<^sub>i_of_stream (LCons (stl s) LNil))" |
|
2294 |
||
62081 | 2295 |
text \<open> |
54072 | 2296 |
\noindent |
54955
cf8d429dc24e
reintroduce recursive calls under constructors, taken out in 8dd0e0316881 mainly and in subsequent changes
blanchet
parents:
54832
diff
changeset
|
2297 |
A more natural syntax, also supported by Isabelle, is to move corecursive calls |
cf8d429dc24e
reintroduce recursive calls under constructors, taken out in 8dd0e0316881 mainly and in subsequent changes
blanchet
parents:
54832
diff
changeset
|
2298 |
under constructors: |
62081 | 2299 |
\<close> |
54072 | 2300 |
|
54955
cf8d429dc24e
reintroduce recursive calls under constructors, taken out in 8dd0e0316881 mainly and in subsequent changes
blanchet
parents:
54832
diff
changeset
|
2301 |
primcorec (*<*)(in late) (*>*)tree\<^sub>i\<^sub>i_of_stream :: "'a stream \<Rightarrow> 'a tree\<^sub>i\<^sub>i" where |
55350 | 2302 |
"tree\<^sub>i\<^sub>i_of_stream s = |
2303 |
Node\<^sub>i\<^sub>i (shd s) (LCons (tree\<^sub>i\<^sub>i_of_stream (stl s)) LNil)" |
|
54072 | 2304 |
|
62081 | 2305 |
text \<open> |
54072 | 2306 |
The next example illustrates corecursion through functions, which is a bit |
2307 |
special. Deterministic finite automata (DFAs) are traditionally defined as |
|
69505 | 2308 |
5-tuples \<open>(Q, \<Sigma>, \<delta>, q\<^sub>0, F)\<close>, where \<open>Q\<close> is a finite set of states, |
2309 |
\<open>\<Sigma>\<close> is a finite alphabet, \<open>\<delta>\<close> is a transition function, \<open>q\<^sub>0\<close> |
|
2310 |
is an initial state, and \<open>F\<close> is a set of final states. The following |
|
55350 | 2311 |
function translates a DFA into a state machine: |
62081 | 2312 |
\<close> |
53675 | 2313 |
|
55350 | 2314 |
primcorec (*<*)(in early) (*>*)sm_of_dfa :: "('q \<Rightarrow> 'a \<Rightarrow> 'q) \<Rightarrow> 'q set \<Rightarrow> 'q \<Rightarrow> 'a sm" where |
2315 |
"sm_of_dfa \<delta> F q = SM (q \<in> F) (sm_of_dfa \<delta> F \<circ> \<delta> q)" |
|
53675 | 2316 |
|
62081 | 2317 |
text \<open> |
53751 | 2318 |
\noindent |
69505 | 2319 |
The map function for the function type (\<open>\<Rightarrow>\<close>) is composition |
2320 |
(\<open>(\<circ>)\<close>). For convenience, corecursion through functions can |
|
54182 | 2321 |
also be expressed using $\lambda$-abstractions and function application rather |
54031 | 2322 |
than through composition. For example: |
62081 | 2323 |
\<close> |
53751 | 2324 |
|
55350 | 2325 |
primcorec sm_of_dfa :: "('q \<Rightarrow> 'a \<Rightarrow> 'q) \<Rightarrow> 'q set \<Rightarrow> 'q \<Rightarrow> 'a sm" where |
2326 |
"sm_of_dfa \<delta> F q = SM (q \<in> F) (\<lambda>a. sm_of_dfa \<delta> F (\<delta> q a))" |
|
53752 | 2327 |
|
62731 | 2328 |
text \<open>\blankline\<close> |
53752 | 2329 |
|
55350 | 2330 |
primcorec empty_sm :: "'a sm" where |
2331 |
"empty_sm = SM False (\<lambda>_. empty_sm)" |
|
53751 | 2332 |
|
62731 | 2333 |
text \<open>\blankline\<close> |
53752 | 2334 |
|
55350 | 2335 |
primcorec not_sm :: "'a sm \<Rightarrow> 'a sm" where |
2336 |
"not_sm M = SM (\<not> accept M) (\<lambda>a. not_sm (trans M a))" |
|
53751 | 2337 |
|
62731 | 2338 |
text \<open>\blankline\<close> |
53752 | 2339 |
|
55350 | 2340 |
primcorec or_sm :: "'a sm \<Rightarrow> 'a sm \<Rightarrow> 'a sm" where |
2341 |
"or_sm M N = |
|
2342 |
SM (accept M \<or> accept N) (\<lambda>a. or_sm (trans M a) (trans N a))" |
|
53751 | 2343 |
|
62081 | 2344 |
text \<open> |
54182 | 2345 |
\noindent |
2346 |
For recursion through curried $n$-ary functions, $n$ applications of |
|
69597 | 2347 |
\<^term>\<open>(\<circ>)\<close> are necessary. The examples below illustrate the case where |
54182 | 2348 |
$n = 2$: |
62081 | 2349 |
\<close> |
54182 | 2350 |
|
55350 | 2351 |
codatatype ('a, 'b) sm2 = |
2352 |
SM2 (accept2: bool) (trans2: "'a \<Rightarrow> 'b \<Rightarrow> ('a, 'b) sm2") |
|
54182 | 2353 |
|
62731 | 2354 |
text \<open>\blankline\<close> |
54182 | 2355 |
|
2356 |
primcorec |
|
55350 | 2357 |
(*<*)(in early) (*>*)sm2_of_dfa :: "('q \<Rightarrow> 'a \<Rightarrow> 'b \<Rightarrow> 'q) \<Rightarrow> 'q set \<Rightarrow> 'q \<Rightarrow> ('a, 'b) sm2" |
54182 | 2358 |
where |
67399 | 2359 |
"sm2_of_dfa \<delta> F q = SM2 (q \<in> F) ((\<circ>) ((\<circ>) (sm2_of_dfa \<delta> F)) (\<delta> q))" |
54182 | 2360 |
|
62731 | 2361 |
text \<open>\blankline\<close> |
54182 | 2362 |
|
2363 |
primcorec |
|
55350 | 2364 |
sm2_of_dfa :: "('q \<Rightarrow> 'a \<Rightarrow> 'b \<Rightarrow> 'q) \<Rightarrow> 'q set \<Rightarrow> 'q \<Rightarrow> ('a, 'b) sm2" |
54182 | 2365 |
where |
55350 | 2366 |
"sm2_of_dfa \<delta> F q = SM2 (q \<in> F) (\<lambda>a b. sm2_of_dfa \<delta> F (\<delta> q a b))" |
54182 | 2367 |
|
53644 | 2368 |
|
62731 | 2369 |
subsubsection \<open>Nested-as-Mutual Corecursion |
2370 |
\label{sssec:primcorec-nested-as-mutual-corecursion}\<close> |
|
62081 | 2371 |
|
2372 |
text \<open> |
|
53647 | 2373 |
Just as it is possible to recurse over nested recursive datatypes as if they |
2374 |
were mutually recursive |
|
2375 |
(Section~\ref{sssec:primrec-nested-as-mutual-recursion}), it is possible to |
|
53752 | 2376 |
pretend that nested codatatypes are mutually corecursive. For example: |
62081 | 2377 |
\<close> |
53647 | 2378 |
|
54287 | 2379 |
(*<*) |
2380 |
context late |
|
2381 |
begin |
|
2382 |
(*>*) |
|
54072 | 2383 |
primcorec |
54287 | 2384 |
iterate\<^sub>i\<^sub>i :: "('a \<Rightarrow> 'a llist) \<Rightarrow> 'a \<Rightarrow> 'a tree\<^sub>i\<^sub>i" and |
53644 | 2385 |
iterates\<^sub>i\<^sub>i :: "('a \<Rightarrow> 'a llist) \<Rightarrow> 'a llist \<Rightarrow> 'a tree\<^sub>i\<^sub>i llist" |
2386 |
where |
|
62081 | 2387 |
"iterate\<^sub>i\<^sub>i g x = Node\<^sub>i\<^sub>i x (iterates\<^sub>i\<^sub>i g (g x))" |
2388 |
| "iterates\<^sub>i\<^sub>i g xs = |
|
53644 | 2389 |
(case xs of |
2390 |
LNil \<Rightarrow> LNil |
|
54072 | 2391 |
| LCons x xs' \<Rightarrow> LCons (iterate\<^sub>i\<^sub>i g x) (iterates\<^sub>i\<^sub>i g xs'))" |
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2392 |
|
62081 | 2393 |
text \<open> |
54287 | 2394 |
\noindent |
2395 |
Coinduction rules are generated as |
|
2396 |
@{thm [source] iterate\<^sub>i\<^sub>i.coinduct}, |
|
2397 |
@{thm [source] iterates\<^sub>i\<^sub>i.coinduct}, and |
|
2398 |
@{thm [source] iterate\<^sub>i\<^sub>i_iterates\<^sub>i\<^sub>i.coinduct} |
|
69505 | 2399 |
and analogously for \<open>coinduct_strong\<close>. These rules and the |
62384 | 2400 |
underlying corecursors are generated dynamically and are kept in a cache |
54287 | 2401 |
to speed up subsequent definitions. |
62081 | 2402 |
\<close> |
54287 | 2403 |
|
2404 |
(*<*) |
|
2405 |
end |
|
2406 |
(*>*) |
|
2407 |
||
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2408 |
|
62731 | 2409 |
subsubsection \<open>Constructor View |
2410 |
\label{ssec:primrec-constructor-view}\<close> |
|
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2411 |
|
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2412 |
(*<*) |
54182 | 2413 |
locale ctr_view |
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2414 |
begin |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2415 |
(*>*) |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2416 |
|
62081 | 2417 |
text \<open> |
53750 | 2418 |
The constructor view is similar to the code view, but there is one separate |
2419 |
conditional equation per constructor rather than a single unconditional |
|
69597 | 2420 |
equation. Examples that rely on a single constructor, such as \<^const>\<open>literate\<close> |
2421 |
and \<^const>\<open>siterate\<close>, are identical in both styles. |
|
53750 | 2422 |
|
2423 |
Here is an example where there is a difference: |
|
62081 | 2424 |
\<close> |
2425 |
||
2426 |
primcorec lapp :: "'a llist \<Rightarrow> 'a llist \<Rightarrow> 'a llist" where |
|
2427 |
"lnull xs \<Longrightarrow> lnull ys \<Longrightarrow> lapp xs ys = LNil" |
|
2428 |
| "_ \<Longrightarrow> lapp xs ys = LCons (lhd (if lnull xs then ys else xs)) |
|
2429 |
(if xs = LNil then ltl ys else lapp (ltl xs) ys)" |
|
2430 |
||
2431 |
text \<open> |
|
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2432 |
\noindent |
69597 | 2433 |
With the constructor view, we must distinguish between the \<^const>\<open>LNil\<close> and |
2434 |
the \<^const>\<open>LCons\<close> case. The condition for \<^const>\<open>LCons\<close> is |
|
2435 |
left implicit, as the negation of that for \<^const>\<open>LNil\<close>. |
|
53750 | 2436 |
|
59861 | 2437 |
For this example, the constructor view is slightly more involved than the |
53750 | 2438 |
code equation. Recall the code view version presented in |
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2439 |
Section~\ref{sssec:primcorec-simple-corecursion}. |
62081 | 2440 |
% TODO: \[{thm code_view.lapp.code}\] |
69597 | 2441 |
The constructor view requires us to analyze the second argument (\<^term>\<open>ys\<close>). |
53752 | 2442 |
The code equation generated from the constructor view also suffers from this. |
62081 | 2443 |
% TODO: \[{thm lapp.code}\] |
53750 | 2444 |
|
53752 | 2445 |
In contrast, the next example is arguably more naturally expressed in the |
2446 |
constructor view: |
|
62081 | 2447 |
\<close> |
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2448 |
|
53831
80423b9080cf
support "of" syntax to disambiguate selector equations
panny
parents:
53829
diff
changeset
|
2449 |
primcorec |
53752 | 2450 |
random_process :: "'a stream \<Rightarrow> (int \<Rightarrow> int) \<Rightarrow> int \<Rightarrow> 'a process" |
2451 |
where |
|
62081 | 2452 |
"n mod 4 = 0 \<Longrightarrow> random_process s f n = Fail" |
2453 |
| "n mod 4 = 1 \<Longrightarrow> |
|
2454 |
random_process s f n = Skip (random_process s f (f n))" |
|
2455 |
| "n mod 4 = 2 \<Longrightarrow> |
|
2456 |
random_process s f n = Action (shd s) (random_process (stl s) f (f n))" |
|
2457 |
| "n mod 4 = 3 \<Longrightarrow> |
|
53752 | 2458 |
random_process s f n = Choice (random_process (every_snd s) f (f n)) |
53826 | 2459 |
(random_process (every_snd (stl s)) f (f n))" |
2460 |
(*<*) |
|
53644 | 2461 |
end |
2462 |
(*>*) |
|
52805 | 2463 |
|
62081 | 2464 |
text \<open> |
53752 | 2465 |
\noindent |
69597 | 2466 |
Since there is no sequentiality, we can apply the equation for \<^const>\<open>Choice\<close> |
2467 |
without having first to discharge \<^term>\<open>n mod (4::int) \<noteq> 0\<close>, |
|
2468 |
\<^term>\<open>n mod (4::int) \<noteq> 1\<close>, and |
|
2469 |
\<^term>\<open>n mod (4::int) \<noteq> 2\<close>. |
|
59284 | 2470 |
The price to pay for this elegance is that we must discharge exclusiveness proof |
53750 | 2471 |
obligations, one for each pair of conditions |
69597 | 2472 |
\<^term>\<open>(n mod (4::int) = i, n mod (4::int) = j)\<close> |
2473 |
with \<^term>\<open>i < j\<close>. If we prefer not to discharge any obligations, we can |
|
69505 | 2474 |
enable the \<open>sequential\<close> option. This pushes the problem to the users of |
53752 | 2475 |
the generated properties. |
53750 | 2476 |
%Here are more examples to conclude: |
62081 | 2477 |
\<close> |
2478 |
||
2479 |
||
62731 | 2480 |
subsubsection \<open>Destructor View |
2481 |
\label{ssec:primrec-destructor-view}\<close> |
|
53752 | 2482 |
|
2483 |
(*<*) |
|
54182 | 2484 |
locale dtr_view |
53752 | 2485 |
begin |
2486 |
(*>*) |
|
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2487 |
|
62081 | 2488 |
text \<open> |
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2489 |
The destructor view is in many respects dual to the constructor view. Conditions |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2490 |
determine which constructor to choose, and these conditions are interpreted |
69505 | 2491 |
sequentially or not depending on the \<open>sequential\<close> option. |
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2492 |
Consider the following examples: |
62081 | 2493 |
\<close> |
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2494 |
|
53826 | 2495 |
primcorec literate :: "('a \<Rightarrow> 'a) \<Rightarrow> 'a \<Rightarrow> 'a llist" where |
62081 | 2496 |
"\<not> lnull (literate _ x)" |
2497 |
| "lhd (literate _ x) = x" |
|
2498 |
| "ltl (literate g x) = literate g (g x)" |
|
2499 |
||
62731 | 2500 |
text \<open>\blankline\<close> |
53752 | 2501 |
|
53826 | 2502 |
primcorec siterate :: "('a \<Rightarrow> 'a) \<Rightarrow> 'a \<Rightarrow> 'a stream" where |
62081 | 2503 |
"shd (siterate _ x) = x" |
2504 |
| "stl (siterate g x) = siterate g (g x)" |
|
2505 |
||
62731 | 2506 |
text \<open>\blankline\<close> |
53752 | 2507 |
|
53826 | 2508 |
primcorec every_snd :: "'a stream \<Rightarrow> 'a stream" where |
62081 | 2509 |
"shd (every_snd s) = shd s" |
2510 |
| "stl (every_snd s) = stl (stl s)" |
|
2511 |
||
2512 |
text \<open> |
|
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2513 |
\noindent |
69597 | 2514 |
The first formula in the \<^const>\<open>literate\<close> specification indicates which |
2515 |
constructor to choose. For \<^const>\<open>siterate\<close> and \<^const>\<open>every_snd\<close>, no such |
|
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2516 |
formula is necessary, since the type has only one constructor. The last two |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2517 |
formulas are equations specifying the value of the result for the relevant |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2518 |
selectors. Corecursive calls appear directly to the right of the equal sign. |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2519 |
Their arguments are unrestricted. |
53750 | 2520 |
|
2521 |
The next example shows how to specify functions that rely on more than one |
|
2522 |
constructor: |
|
62081 | 2523 |
\<close> |
2524 |
||
2525 |
primcorec lapp :: "'a llist \<Rightarrow> 'a llist \<Rightarrow> 'a llist" where |
|
2526 |
"lnull xs \<Longrightarrow> lnull ys \<Longrightarrow> lnull (lapp xs ys)" |
|
2527 |
| "lhd (lapp xs ys) = lhd (if lnull xs then ys else xs)" |
|
2528 |
| "ltl (lapp xs ys) = (if xs = LNil then ltl ys else lapp (ltl xs) ys)" |
|
2529 |
||
2530 |
text \<open> |
|
53750 | 2531 |
\noindent |
2532 |
For a codatatype with $n$ constructors, it is sufficient to specify $n - 1$ |
|
2533 |
discriminator formulas. The command will then assume that the remaining |
|
2534 |
constructor should be taken otherwise. This can be made explicit by adding |
|
62081 | 2535 |
\<close> |
53750 | 2536 |
|
2537 |
(*<*) |
|
2538 |
end |
|
2539 |
||
54182 | 2540 |
locale dtr_view2 |
2541 |
begin |
|
2542 |
||
62081 | 2543 |
primcorec lapp :: "'a llist \<Rightarrow> 'a llist \<Rightarrow> 'a llist" where |
2544 |
"lnull xs \<Longrightarrow> lnull ys \<Longrightarrow> lnull (lapp xs ys)" |
|
2545 |
| "lhd (lapp xs ys) = lhd (if lnull xs then ys else xs)" |
|
2546 |
| "ltl (lapp xs ys) = (if xs = LNil then ltl ys else lapp (ltl xs) ys)" | |
|
53750 | 2547 |
(*>*) |
62081 | 2548 |
"_ \<Longrightarrow> \<not> lnull (lapp xs ys)" |
2549 |
||
2550 |
text \<open> |
|
53750 | 2551 |
\noindent |
53752 | 2552 |
to the specification. The generated selector theorems are conditional. |
2553 |
||
2554 |
The next example illustrates how to cope with selectors defined for several |
|
53750 | 2555 |
constructors: |
62081 | 2556 |
\<close> |
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2557 |
|
53831
80423b9080cf
support "of" syntax to disambiguate selector equations
panny
parents:
53829
diff
changeset
|
2558 |
primcorec |
53752 | 2559 |
random_process :: "'a stream \<Rightarrow> (int \<Rightarrow> int) \<Rightarrow> int \<Rightarrow> 'a process" |
2560 |
where |
|
62081 | 2561 |
"n mod 4 = 0 \<Longrightarrow> random_process s f n = Fail" |
2562 |
| "n mod 4 = 1 \<Longrightarrow> is_Skip (random_process s f n)" |
|
2563 |
| "n mod 4 = 2 \<Longrightarrow> is_Action (random_process s f n)" |
|
2564 |
| "n mod 4 = 3 \<Longrightarrow> is_Choice (random_process s f n)" |
|
2565 |
| "cont (random_process s f n) = random_process s f (f n)" of Skip |
|
2566 |
| "prefix (random_process s f n) = shd s" |
|
2567 |
| "cont (random_process s f n) = random_process (stl s) f (f n)" of Action |
|
2568 |
| "left (random_process s f n) = random_process (every_snd s) f (f n)" |
|
2569 |
| "right (random_process s f n) = random_process (every_snd (stl s)) f (f n)" |
|
2570 |
||
2571 |
text \<open> |
|
53750 | 2572 |
\noindent |
69597 | 2573 |
Using the \<open>of\<close> keyword, different equations are specified for \<^const>\<open>cont\<close> depending on which constructor is selected. |
53750 | 2574 |
|
2575 |
Here are more examples to conclude: |
|
62081 | 2576 |
\<close> |
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2577 |
|
53826 | 2578 |
primcorec |
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2579 |
even_infty :: even_enat and |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2580 |
odd_infty :: odd_enat |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2581 |
where |
62081 | 2582 |
"even_infty \<noteq> Even_EZero" |
2583 |
| "un_Even_ESucc even_infty = odd_infty" |
|
2584 |
| "un_Odd_ESucc odd_infty = even_infty" |
|
2585 |
||
62731 | 2586 |
text \<open>\blankline\<close> |
53752 | 2587 |
|
53826 | 2588 |
primcorec iterate\<^sub>i\<^sub>i :: "('a \<Rightarrow> 'a llist) \<Rightarrow> 'a \<Rightarrow> 'a tree\<^sub>i\<^sub>i" where |
62081 | 2589 |
"lbl\<^sub>i\<^sub>i (iterate\<^sub>i\<^sub>i g x) = x" |
2590 |
| "sub\<^sub>i\<^sub>i (iterate\<^sub>i\<^sub>i g x) = lmap (iterate\<^sub>i\<^sub>i g) (g x)" |
|
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2591 |
(*<*) |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2592 |
end |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2593 |
(*>*) |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2594 |
|
53750 | 2595 |
|
62731 | 2596 |
subsection \<open>Command Syntax |
2597 |
\label{ssec:primcorec-command-syntax}\<close> |
|
2598 |
||
2599 |
subsubsection \<open>\keyw{primcorec} and \keyw{primcorecursive} |
|
2600 |
\label{sssec:primcorecursive-and-primcorec}\<close> |
|
62081 | 2601 |
|
2602 |
text \<open> |
|
53829 | 2603 |
\begin{matharray}{rcl} |
69505 | 2604 |
@{command_def "primcorec"} & : & \<open>local_theory \<rightarrow> local_theory\<close> \\ |
2605 |
@{command_def "primcorecursive"} & : & \<open>local_theory \<rightarrow> proof(prove)\<close> |
|
53829 | 2606 |
\end{matharray} |
52840 | 2607 |
|
69597 | 2608 |
\<^rail>\<open> |
55029
61a6bf7d4b02
clarified @{rail} syntax: prefer explicit \<newline> symbol;
wenzelm
parents:
54958
diff
changeset
|
2609 |
(@@{command primcorec} | @@{command primcorecursive}) target? \<newline> |
59277 | 2610 |
@{syntax pcr_options}? fixes @'where' (@{syntax pcr_formula} + '|') |
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2611 |
; |
59282 | 2612 |
@{syntax_def pcr_options}: '(' ((@{syntax plugins} | 'sequential' | 'exhaustive' | 'transfer') + ',') ')' |
52840 | 2613 |
; |
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2614 |
@{syntax_def pcr_formula}: thmdecl? prop (@'of' (term * ))? |
69597 | 2615 |
\<close> |
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2616 |
|
55351 | 2617 |
\medskip |
2618 |
||
2619 |
\noindent |
|
55474 | 2620 |
The @{command primcorec} and @{command primcorecursive} commands introduce a set |
2621 |
of mutually corecursive functions over codatatypes. |
|
55460
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
2622 |
|
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
2623 |
The syntactic entity \synt{target} can be used to specify a local context, |
55474 | 2624 |
\synt{fixes} denotes a list of names with optional type signatures, |
2625 |
\synt{thmdecl} denotes an optional name for the formula that follows, and |
|
76987 | 2626 |
\synt{prop} denotes a HOL proposition \<^cite>\<open>"isabelle-isar-ref"\<close>. |
55460
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
2627 |
|
59280 | 2628 |
The optional target is optionally followed by a combination of the following |
56124 | 2629 |
options: |
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2630 |
|
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2631 |
\begin{itemize} |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2632 |
\setlength{\itemsep}{0pt} |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2633 |
|
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2634 |
\item |
69505 | 2635 |
The \<open>plugins\<close> option indicates which plugins should be enabled |
2636 |
(\<open>only\<close>) or disabled (\<open>del\<close>). By default, all plugins are enabled. |
|
59282 | 2637 |
|
2638 |
\item |
|
69505 | 2639 |
The \<open>sequential\<close> option indicates that the conditions in specifications |
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2640 |
expressed using the constructor or destructor view are to be interpreted |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2641 |
sequentially. |
53826 | 2642 |
|
2643 |
\item |
|
69505 | 2644 |
The \<open>exhaustive\<close> option indicates that the conditions in specifications |
53826 | 2645 |
expressed using the constructor or destructor view cover all possible cases. |
59284 | 2646 |
This generally gives rise to an additional proof obligation. |
59277 | 2647 |
|
2648 |
\item |
|
69505 | 2649 |
The \<open>transfer\<close> option indicates that an unconditional transfer rule |
2650 |
should be generated and proved \<open>by transfer_prover\<close>. The |
|
2651 |
\<open>[transfer_rule]\<close> attribute is set on the generated theorem. |
|
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2652 |
\end{itemize} |
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
2653 |
|
55474 | 2654 |
The @{command primcorec} command is an abbreviation for @{command |
69505 | 2655 |
primcorecursive} with \<open>by auto?\<close> to discharge any emerging proof |
55474 | 2656 |
obligations. |
55460
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
2657 |
|
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
2658 |
%%% TODO: elaborate on format of the propositions |
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
2659 |
%%% TODO: elaborate on mutual and nested-to-mutual |
62081 | 2660 |
\<close> |
2661 |
||
2662 |
||
62731 | 2663 |
subsection \<open>Generated Theorems |
2664 |
\label{ssec:primcorec-generated-theorems}\<close> |
|
62081 | 2665 |
|
2666 |
text \<open> |
|
59284 | 2667 |
The @{command primcorec} and @{command primcorecursive} commands generate the |
69597 | 2668 |
following properties (listed for \<^const>\<open>literate\<close>): |
59284 | 2669 |
|
2670 |
\begin{indentblock} |
|
2671 |
\begin{description} |
|
2672 |
||
69505 | 2673 |
\item[\<open>f.\<close>\hthm{code} \<open>[code]\<close>\rm:] ~ \\ |
59284 | 2674 |
@{thm literate.code[no_vars]} \\ |
69505 | 2675 |
The \<open>[code]\<close> attribute is set by the \<open>code\<close> plugin |
59284 | 2676 |
(Section~\ref{ssec:code-generator}). |
2677 |
||
69505 | 2678 |
\item[\<open>f.\<close>\hthm{ctr}\rm:] ~ \\ |
59284 | 2679 |
@{thm literate.ctr[no_vars]} |
2680 |
||
69505 | 2681 |
\item[\<open>f.\<close>\hthm{disc} \<open>[simp, code]\<close>\rm:] ~ \\ |
59284 | 2682 |
@{thm literate.disc[no_vars]} \\ |
69505 | 2683 |
The \<open>[code]\<close> attribute is set by the \<open>code\<close> plugin |
2684 |
(Section~\ref{ssec:code-generator}). The \<open>[simp]\<close> attribute is set only |
|
2685 |
for functions for which \<open>f.disc_iff\<close> is not available. |
|
2686 |
||
2687 |
\item[\<open>f.\<close>\hthm{disc_iff} \<open>[simp]\<close>\rm:] ~ \\ |
|
59284 | 2688 |
@{thm literate.disc_iff[no_vars]} \\ |
2689 |
This property is generated only for functions declared with the |
|
69505 | 2690 |
\<open>exhaustive\<close> option or whose conditions are trivially exhaustive. |
2691 |
||
2692 |
\item[\<open>f.\<close>\hthm{sel} \<open>[simp, code]\<close>\rm:] ~ \\ |
|
59284 | 2693 |
@{thm literate.disc[no_vars]} \\ |
69505 | 2694 |
The \<open>[code]\<close> attribute is set by the \<open>code\<close> plugin |
59284 | 2695 |
(Section~\ref{ssec:code-generator}). |
2696 |
||
69505 | 2697 |
\item[\<open>f.\<close>\hthm{exclude}\rm:] ~ \\ |
69597 | 2698 |
These properties are missing for \<^const>\<open>literate\<close> because no exclusiveness |
59284 | 2699 |
proof obligations arose. In general, the properties correspond to the |
2700 |
discharged proof obligations. |
|
2701 |
||
69505 | 2702 |
\item[\<open>f.\<close>\hthm{exhaust}\rm:] ~ \\ |
69597 | 2703 |
This property is missing for \<^const>\<open>literate\<close> because no exhaustiveness |
59284 | 2704 |
proof obligation arose. In general, the property correspond to the discharged |
2705 |
proof obligation. |
|
2706 |
||
2707 |
\item[\begin{tabular}{@ {}l@ {}} |
|
69505 | 2708 |
\<open>f.\<close>\hthm{coinduct} \<open>[consumes m, case_names t\<^sub>1 \<dots> t\<^sub>m,\<close> \\ |
2709 |
\phantom{\<open>f.\<close>\hthm{coinduct} \<open>[\<close>}\<open>case_conclusion D\<^sub>1 \<dots> |
|
2710 |
D\<^sub>n]\<close>\rm: |
|
59284 | 2711 |
\end{tabular}] ~ \\ |
2712 |
This coinduction rule is generated for nested-as-mutual corecursive functions |
|
2713 |
(Section~\ref{sssec:primcorec-nested-as-mutual-corecursion}). |
|
2714 |
||
2715 |
\item[\begin{tabular}{@ {}l@ {}} |
|
69505 | 2716 |
\<open>f.\<close>\hthm{coinduct_strong} \<open>[consumes m, case_names t\<^sub>1 \<dots> t\<^sub>m,\<close> \\ |
2717 |
\phantom{\<open>f.\<close>\hthm{coinduct_strong} \<open>[\<close>}\<open>case_conclusion D\<^sub>1 \<dots> |
|
2718 |
D\<^sub>n]\<close>\rm: |
|
59284 | 2719 |
\end{tabular}] ~ \\ |
2720 |
This coinduction rule is generated for nested-as-mutual corecursive functions |
|
2721 |
(Section~\ref{sssec:primcorec-nested-as-mutual-corecursion}). |
|
2722 |
||
2723 |
\item[\begin{tabular}{@ {}l@ {}} |
|
69505 | 2724 |
\<open>f\<^sub>1_\<dots>_f\<^sub>m.\<close>\hthm{coinduct} \<open>[case_names t\<^sub>1 \<dots> t\<^sub>m,\<close> \\ |
2725 |
\phantom{\<open>f.\<close>\hthm{coinduct} \<open>[\<close>}\<open>case_conclusion D\<^sub>1 \<dots> |
|
2726 |
D\<^sub>n]\<close>\rm: |
|
59284 | 2727 |
\end{tabular}] ~ \\ |
2728 |
This coinduction rule is generated for nested-as-mutual corecursive functions |
|
2729 |
(Section~\ref{sssec:primcorec-nested-as-mutual-corecursion}). Given $m > 1$ |
|
2730 |
mutually corecursive functions, this rule can be used to prove $m$ properties |
|
2731 |
simultaneously. |
|
2732 |
||
2733 |
\item[\begin{tabular}{@ {}l@ {}} |
|
69505 | 2734 |
\<open>f\<^sub>1_\<dots>_f\<^sub>m.\<close>\hthm{coinduct_strong} \<open>[case_names t\<^sub>1 \<dots> t\<^sub>m,\<close> \\ |
2735 |
\phantom{\<open>f.\<close>\hthm{coinduct_strong} \<open>[\<close>}\<open>case_conclusion D\<^sub>1 \<dots> |
|
2736 |
D\<^sub>n]\<close>\rm: |
|
59284 | 2737 |
\end{tabular}] ~ \\ |
2738 |
This coinduction rule is generated for nested-as-mutual corecursive functions |
|
2739 |
(Section~\ref{sssec:primcorec-nested-as-mutual-corecursion}). Given $m > 1$ |
|
2740 |
mutually corecursive functions, this rule can be used to prove $m$ properties |
|
2741 |
simultaneously. |
|
2742 |
||
2743 |
\end{description} |
|
2744 |
\end{indentblock} |
|
2745 |
||
2746 |
\noindent |
|
2747 |
For convenience, @{command primcorec} and @{command primcorecursive} also |
|
2748 |
provide the following collection: |
|
2749 |
||
2750 |
\begin{indentblock} |
|
2751 |
\begin{description} |
|
2752 |
||
69505 | 2753 |
\item[\<open>f.\<close>\hthm{simps}] = \<open>f.disc_iff\<close> (or \<open>f.disc\<close>) \<open>t.sel\<close> |
59284 | 2754 |
|
2755 |
\end{description} |
|
2756 |
\end{indentblock} |
|
62081 | 2757 |
\<close> |
52794 | 2758 |
|
2759 |
||
53623 | 2760 |
(* |
62731 | 2761 |
subsection \<open>Recursive Default Values for Selectors |
2762 |
\label{ssec:primcorec-recursive-default-values-for-selectors}\<close> |
|
62081 | 2763 |
|
2764 |
text \<open> |
|
53623 | 2765 |
partial_function to the rescue |
62081 | 2766 |
\<close> |
53623 | 2767 |
*) |
2768 |
||
2769 |
||
62731 | 2770 |
section \<open>Registering Bounded Natural Functors |
2771 |
\label{sec:registering-bounded-natural-functors}\<close> |
|
62081 | 2772 |
|
2773 |
text \<open> |
|
53647 | 2774 |
The (co)datatype package can be set up to allow nested recursion through |
55350 | 2775 |
arbitrary type constructors, as long as they adhere to the BNF requirements |
2776 |
and are registered as BNFs. It is also possible to declare a BNF abstractly |
|
2777 |
without specifying its internal structure. |
|
62081 | 2778 |
\<close> |
2779 |
||
2780 |
||
62731 | 2781 |
subsection \<open>Bounded Natural Functors |
2782 |
\label{ssec:bounded-natural-functors}\<close> |
|
62081 | 2783 |
|
2784 |
text \<open> |
|
55350 | 2785 |
Bounded natural functors (BNFs) are a semantic criterion for where |
2786 |
(co)re\-cur\-sion may appear on the right-hand side of an equation |
|
76987 | 2787 |
\<^cite>\<open>"traytel-et-al-2012" and "blanchette-et-al-2015-wit"\<close>. |
55350 | 2788 |
|
2789 |
An $n$-ary BNF is a type constructor equipped with a map function |
|
2790 |
(functorial action), $n$ set functions (natural transformations), |
|
2791 |
and an infinite cardinal bound that satisfy certain properties. |
|
69597 | 2792 |
For example, \<^typ>\<open>'a llist\<close> is a unary BNF. |
69505 | 2793 |
Its predicator \<open>llist_all :: |
62330 | 2794 |
('a \<Rightarrow> bool) \<Rightarrow> |
69505 | 2795 |
'a llist \<Rightarrow> bool\<close> |
62330 | 2796 |
extends unary predicates over elements to unary predicates over |
2797 |
lazy lists. |
|
69505 | 2798 |
Similarly, its relator \<open>llist_all2 :: |
55350 | 2799 |
('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> |
69505 | 2800 |
'a llist \<Rightarrow> 'b llist \<Rightarrow> bool\<close> |
55350 | 2801 |
extends binary predicates over elements to binary predicates over parallel |
2802 |
lazy lists. The cardinal bound limits the number of elements returned by the |
|
69597 | 2803 |
set function; it may not depend on the cardinality of \<^typ>\<open>'a\<close>. |
55350 | 2804 |
|
58310 | 2805 |
The type constructors introduced by @{command datatype} and |
55350 | 2806 |
@{command codatatype} are automatically registered as BNFs. In addition, a |
2807 |
number of old-style datatypes and non-free types are preregistered. |
|
2808 |
||
2809 |
Given an $n$-ary BNF, the $n$ type variables associated with set functions, |
|
2810 |
and on which the map function acts, are \emph{live}; any other variables are |
|
2811 |
\emph{dead}. Nested (co)recursion can only take place through live variables. |
|
62081 | 2812 |
\<close> |
2813 |
||
2814 |
||
62731 | 2815 |
subsection \<open>Introductory Examples |
2816 |
\label{ssec:bnf-introductory-examples}\<close> |
|
62081 | 2817 |
|
2818 |
text \<open> |
|
55350 | 2819 |
The example below shows how to register a type as a BNF using the @{command bnf} |
70078 | 2820 |
command. Some of the proof obligations are best viewed with the bundle |
2821 |
"cardinal_syntax" included. |
|
55350 | 2822 |
|
69597 | 2823 |
The type is simply a copy of the function space \<^typ>\<open>'d \<Rightarrow> 'a\<close>, where \<^typ>\<open>'a\<close> |
2824 |
is live and \<^typ>\<open>'d\<close> is dead. We introduce it together with its map function, |
|
62330 | 2825 |
set function, predicator, and relator. |
62081 | 2826 |
\<close> |
55350 | 2827 |
|
61076 | 2828 |
typedef ('d, 'a) fn = "UNIV :: ('d \<Rightarrow> 'a) set" |
60152 | 2829 |
by simp |
2830 |
||
62731 | 2831 |
text \<open>\blankline\<close> |
55459
1cd927ca8296
cleaner, complete proof in documentation, contributed by Dmitriy T.
blanchet
parents:
55410
diff
changeset
|
2832 |
|
1cd927ca8296
cleaner, complete proof in documentation, contributed by Dmitriy T.
blanchet
parents:
55410
diff
changeset
|
2833 |
setup_lifting type_definition_fn |
55350 | 2834 |
|
62731 | 2835 |
text \<open>\blankline\<close> |
55350 | 2836 |
|
67399 | 2837 |
lift_definition map_fn :: "('a \<Rightarrow> 'b) \<Rightarrow> ('d, 'a) fn \<Rightarrow> ('d, 'b) fn" is "(\<circ>)" . |
55459
1cd927ca8296
cleaner, complete proof in documentation, contributed by Dmitriy T.
blanchet
parents:
55410
diff
changeset
|
2838 |
lift_definition set_fn :: "('d, 'a) fn \<Rightarrow> 'a set" is range . |
55350 | 2839 |
|
62731 | 2840 |
text \<open>\blankline\<close> |
55350 | 2841 |
|
55459
1cd927ca8296
cleaner, complete proof in documentation, contributed by Dmitriy T.
blanchet
parents:
55410
diff
changeset
|
2842 |
lift_definition |
62330 | 2843 |
pred_fn :: "('a \<Rightarrow> bool) \<Rightarrow> ('d, 'a) fn \<Rightarrow> bool" |
2844 |
is |
|
2845 |
"pred_fun (\<lambda>_. True)" . |
|
2846 |
||
2847 |
lift_definition |
|
55350 | 2848 |
rel_fn :: "('a \<Rightarrow> 'b \<Rightarrow> bool) \<Rightarrow> ('d, 'a) fn \<Rightarrow> ('d, 'b) fn \<Rightarrow> bool" |
55459
1cd927ca8296
cleaner, complete proof in documentation, contributed by Dmitriy T.
blanchet
parents:
55410
diff
changeset
|
2849 |
is |
67399 | 2850 |
"rel_fun (=)" . |
55350 | 2851 |
|
62731 | 2852 |
text \<open>\blankline\<close> |
55350 | 2853 |
|
2854 |
bnf "('d, 'a) fn" |
|
2855 |
map: map_fn |
|
2856 |
sets: set_fn |
|
75625
0dd3ac5fdbaa
tuned BNF bounds for function space and bounded sets; NEWS and CONTRIBUTORS
traytel
parents:
75624
diff
changeset
|
2857 |
bd: "natLeq +c card_suc |UNIV :: 'd set|" |
55350 | 2858 |
rel: rel_fn |
62330 | 2859 |
pred: pred_fn |
55350 | 2860 |
proof - |
2861 |
show "map_fn id = id" |
|
55459
1cd927ca8296
cleaner, complete proof in documentation, contributed by Dmitriy T.
blanchet
parents:
55410
diff
changeset
|
2862 |
by transfer auto |
55350 | 2863 |
next |
60136 | 2864 |
fix f :: "'a \<Rightarrow> 'b" and g :: "'b \<Rightarrow> 'c" |
2865 |
show "map_fn (g \<circ> f) = map_fn g \<circ> map_fn f" |
|
55459
1cd927ca8296
cleaner, complete proof in documentation, contributed by Dmitriy T.
blanchet
parents:
55410
diff
changeset
|
2866 |
by transfer (auto simp add: comp_def) |
55350 | 2867 |
next |
60136 | 2868 |
fix F :: "('d, 'a) fn" and f g :: "'a \<Rightarrow> 'b" |
55350 | 2869 |
assume "\<And>x. x \<in> set_fn F \<Longrightarrow> f x = g x" |
61303 | 2870 |
then show "map_fn f F = map_fn g F" |
55459
1cd927ca8296
cleaner, complete proof in documentation, contributed by Dmitriy T.
blanchet
parents:
55410
diff
changeset
|
2871 |
by transfer auto |
55350 | 2872 |
next |
60136 | 2873 |
fix f :: "'a \<Rightarrow> 'b" |
67399 | 2874 |
show "set_fn \<circ> map_fn f = (`) f \<circ> set_fn" |
55459
1cd927ca8296
cleaner, complete proof in documentation, contributed by Dmitriy T.
blanchet
parents:
55410
diff
changeset
|
2875 |
by transfer (auto simp add: comp_def) |
55350 | 2876 |
next |
75625
0dd3ac5fdbaa
tuned BNF bounds for function space and bounded sets; NEWS and CONTRIBUTORS
traytel
parents:
75624
diff
changeset
|
2877 |
show "card_order (natLeq +c card_suc |UNIV :: 'd set| )" |
0dd3ac5fdbaa
tuned BNF bounds for function space and bounded sets; NEWS and CONTRIBUTORS
traytel
parents:
75624
diff
changeset
|
2878 |
by (rule card_order_bd_fun) |
55350 | 2879 |
next |
75625
0dd3ac5fdbaa
tuned BNF bounds for function space and bounded sets; NEWS and CONTRIBUTORS
traytel
parents:
75624
diff
changeset
|
2880 |
show "cinfinite (natLeq +c card_suc |UNIV :: 'd set| )" |
0dd3ac5fdbaa
tuned BNF bounds for function space and bounded sets; NEWS and CONTRIBUTORS
traytel
parents:
75624
diff
changeset
|
2881 |
by (rule Cinfinite_bd_fun[THEN conjunct1]) |
75624 | 2882 |
next |
75625
0dd3ac5fdbaa
tuned BNF bounds for function space and bounded sets; NEWS and CONTRIBUTORS
traytel
parents:
75624
diff
changeset
|
2883 |
show "regularCard (natLeq +c card_suc |UNIV :: 'd set| )" |
0dd3ac5fdbaa
tuned BNF bounds for function space and bounded sets; NEWS and CONTRIBUTORS
traytel
parents:
75624
diff
changeset
|
2884 |
by (rule regularCard_bd_fun) |
55350 | 2885 |
next |
2886 |
fix F :: "('d, 'a) fn" |
|
61076 | 2887 |
have "|set_fn F| \<le>o |UNIV :: 'd set|" (is "_ \<le>o ?U") |
55459
1cd927ca8296
cleaner, complete proof in documentation, contributed by Dmitriy T.
blanchet
parents:
55410
diff
changeset
|
2888 |
by transfer (rule card_of_image) |
75625
0dd3ac5fdbaa
tuned BNF bounds for function space and bounded sets; NEWS and CONTRIBUTORS
traytel
parents:
75624
diff
changeset
|
2889 |
also have "?U <o card_suc ?U" |
0dd3ac5fdbaa
tuned BNF bounds for function space and bounded sets; NEWS and CONTRIBUTORS
traytel
parents:
75624
diff
changeset
|
2890 |
by (simp add: card_of_card_order_on card_suc_greater) |
0dd3ac5fdbaa
tuned BNF bounds for function space and bounded sets; NEWS and CONTRIBUTORS
traytel
parents:
75624
diff
changeset
|
2891 |
also have "card_suc ?U \<le>o natLeq +c card_suc ?U" |
0dd3ac5fdbaa
tuned BNF bounds for function space and bounded sets; NEWS and CONTRIBUTORS
traytel
parents:
75624
diff
changeset
|
2892 |
using Card_order_card_suc card_of_card_order_on ordLeq_csum2 by blast |
0dd3ac5fdbaa
tuned BNF bounds for function space and bounded sets; NEWS and CONTRIBUTORS
traytel
parents:
75624
diff
changeset
|
2893 |
finally show "|set_fn F| <o natLeq +c card_suc |UNIV :: 'd set|" . |
55350 | 2894 |
next |
60136 | 2895 |
fix R :: "'a \<Rightarrow> 'b \<Rightarrow> bool" and S :: "'b \<Rightarrow> 'c \<Rightarrow> bool" |
55350 | 2896 |
show "rel_fn R OO rel_fn S \<le> rel_fn (R OO S)" |
55945 | 2897 |
by (rule, transfer) (auto simp add: rel_fun_def) |
55350 | 2898 |
next |
60136 | 2899 |
fix R :: "'a \<Rightarrow> 'b \<Rightarrow> bool" |
62324 | 2900 |
show "rel_fn R = (\<lambda>x y. \<exists>z. set_fn z \<subseteq> {(x, y). R x y} \<and> map_fn fst z = x \<and> map_fn snd z = y)" |
2901 |
unfolding fun_eq_iff relcompp.simps conversep.simps |
|
2902 |
by transfer (force simp: rel_fun_def subset_iff) |
|
62330 | 2903 |
next |
2904 |
fix P :: "'a \<Rightarrow> bool" |
|
2905 |
show "pred_fn P = (\<lambda>x. Ball (set_fn x) P)" |
|
2906 |
unfolding fun_eq_iff by transfer simp |
|
55350 | 2907 |
qed |
2908 |
||
62731 | 2909 |
text \<open>\blankline\<close> |
55350 | 2910 |
|
2911 |
print_theorems |
|
2912 |
print_bnfs |
|
2913 |
||
62081 | 2914 |
text \<open> |
55350 | 2915 |
\noindent |
58931 | 2916 |
Using \keyw{print_theorems} and @{command print_bnfs}, we can contemplate and |
55350 | 2917 |
show the world what we have achieved. |
2918 |
||
2919 |
This particular example does not need any nonemptiness witness, because the |
|
2920 |
one generated by default is good enough, but in general this would be |
|
63680 | 2921 |
necessary. See \<^file>\<open>~~/src/HOL/Basic_BNFs.thy\<close>, |
2922 |
\<^file>\<open>~~/src/HOL/Library/Countable_Set_Type.thy\<close>, |
|
2923 |
\<^file>\<open>~~/src/HOL/Library/FSet.thy\<close>, and |
|
2924 |
\<^file>\<open>~~/src/HOL/Library/Multiset.thy\<close> for further examples of BNF |
|
61304 | 2925 |
registration, some of which feature custom witnesses. |
55350 | 2926 |
|
71264 | 2927 |
For many typedefs and quotient types, lifting the BNF structure from the raw typ |
2928 |
to the abstract type can be done uniformly. This is the task of the @{command lift_bnf} |
|
2929 |
command. Using @{command lift_bnf}, the above registration of \<^typ>\<open>('d, 'a) fn\<close> as a |
|
61303 | 2930 |
BNF becomes much shorter: |
62081 | 2931 |
\<close> |
60920 | 2932 |
|
61303 | 2933 |
(*<*) |
2934 |
context early |
|
2935 |
begin |
|
2936 |
(*>*) |
|
2937 |
lift_bnf (*<*)(no_warn_wits) (*>*)('d, 'a) fn |
|
71264 | 2938 |
by force+ |
61303 | 2939 |
(*<*) |
2940 |
end |
|
2941 |
(*>*) |
|
60920 | 2942 |
|
62081 | 2943 |
text \<open> |
69597 | 2944 |
For type copies (@{command typedef}s with \<^term>\<open>UNIV\<close> as the representing set), |
61303 | 2945 |
the proof obligations are so simple that they can be |
2946 |
discharged automatically, yielding another command, @{command copy_bnf}, which |
|
2947 |
does not emit any proof obligations: |
|
62081 | 2948 |
\<close> |
60920 | 2949 |
|
61303 | 2950 |
(*<*) |
2951 |
context late |
|
2952 |
begin |
|
2953 |
(*>*) |
|
60920 | 2954 |
copy_bnf ('d, 'a) fn |
61303 | 2955 |
(*<*) |
2956 |
end |
|
2957 |
(*>*) |
|
60920 | 2958 |
|
62081 | 2959 |
text \<open> |
61303 | 2960 |
Since record schemas are type copies, @{command copy_bnf} can be used to |
2961 |
register them as BNFs: |
|
62081 | 2962 |
\<close> |
60920 | 2963 |
|
2964 |
record 'a point = |
|
2965 |
xval :: 'a |
|
2966 |
yval :: 'a |
|
61303 | 2967 |
|
62731 | 2968 |
text \<open>\blankline\<close> |
62333 | 2969 |
|
71264 | 2970 |
copy_bnf (*<*)(no_warn_transfer) (*>*)('a, 'z) point_ext |
60920 | 2971 |
|
62081 | 2972 |
text \<open> |
61303 | 2973 |
In the general case, the proof obligations generated by @{command lift_bnf} are |
2974 |
simpler than the acual BNF properties. In particular, no cardinality reasoning |
|
2975 |
is required. Consider the following type of nonempty lists: |
|
62081 | 2976 |
\<close> |
60920 | 2977 |
|
2978 |
typedef 'a nonempty_list = "{xs :: 'a list. xs \<noteq> []}" by auto |
|
2979 |
||
62081 | 2980 |
text \<open> |
61303 | 2981 |
The @{command lift_bnf} command requires us to prove that the set of nonempty lists |
2982 |
is closed under the map function and the zip function. The latter only |
|
60920 | 2983 |
occurs implicitly in the goal, in form of the variable |
69597 | 2984 |
\<^term>\<open>zs :: ('a \<times> 'b) list\<close>. |
62081 | 2985 |
\<close> |
60920 | 2986 |
|
71264 | 2987 |
lift_bnf (*<*)(no_warn_wits,no_warn_transfer) (*>*)'a nonempty_list |
60920 | 2988 |
proof - |
62330 | 2989 |
fix f (*<*):: "'a \<Rightarrow> 'c"(*>*)and xs :: "'a list" |
60920 | 2990 |
assume "xs \<in> {xs. xs \<noteq> []}" |
61303 | 2991 |
then show "map f xs \<in> {xs. xs \<noteq> []}" |
2992 |
by (cases xs(*<*) rule: list.exhaust(*>*)) auto |
|
60920 | 2993 |
next |
2994 |
fix zs :: "('a \<times> 'b) list" |
|
2995 |
assume "map fst zs \<in> {xs. xs \<noteq> []}" "map snd zs \<in> {xs. xs \<noteq> []}" |
|
71264 | 2996 |
then show "\<exists>zs'\<in>{xs. xs \<noteq> []}. |
2997 |
set zs' \<subseteq> set zs \<and> |
|
2998 |
map fst zs' = map fst zs \<and> |
|
2999 |
map snd zs' = map snd zs" |
|
3000 |
by (cases zs (*<*)rule: list.exhaust(*>*)) (auto intro!: exI[of _ zs]) |
|
60920 | 3001 |
qed |
3002 |
||
71264 | 3003 |
text \<open>The @{command lift_bnf} command also supports quotient types. Here is an example |
3004 |
that defines the option type as a quotient of the sum type. The proof obligations |
|
71393
fce780f9c9c6
new examples of BNF lifting across quotients using a new theory of confluence,
traytel
parents:
71354
diff
changeset
|
3005 |
generated by @{command lift_bnf} for quotients are different from the ones for typedefs. |
fce780f9c9c6
new examples of BNF lifting across quotients using a new theory of confluence,
traytel
parents:
71354
diff
changeset
|
3006 |
You can find additional examples of usages of @{command lift_bnf} for both quotients and subtypes |
fce780f9c9c6
new examples of BNF lifting across quotients using a new theory of confluence,
traytel
parents:
71354
diff
changeset
|
3007 |
in the session \emph{HOL-Datatype_Examples}.\<close> |
71264 | 3008 |
|
3009 |
inductive ignore_Inl :: "'a + 'a \<Rightarrow> 'a + 'a \<Rightarrow> bool" where |
|
3010 |
"ignore_Inl (Inl x) (Inl y)" |
|
3011 |
| "ignore_Inl (Inr x) (Inr x)" |
|
3012 |
||
3013 |
(*<*) |
|
3014 |
inductive_simps ignore_Inl_simps[simp]: |
|
3015 |
"ignore_Inl (Inl x) y" |
|
3016 |
"ignore_Inl (Inr x') y" |
|
3017 |
"ignore_Inl y (Inl x)" |
|
3018 |
"ignore_Inl y (Inr x')" |
|
3019 |
(*>*) |
|
3020 |
||
3021 |
lemma ignore_Inl_equivp: |
|
3022 |
"ignore_Inl x x" |
|
3023 |
"ignore_Inl x y \<Longrightarrow> ignore_Inl y x" |
|
3024 |
"ignore_Inl x y \<Longrightarrow> ignore_Inl y z \<Longrightarrow> ignore_Inl x z" |
|
3025 |
by (cases x; cases y; cases z; auto)+ |
|
3026 |
||
3027 |
quotient_type 'a myoption = "'a + 'a" / ignore_Inl |
|
3028 |
unfolding equivp_reflp_symp_transp reflp_def symp_def transp_def |
|
3029 |
by (blast intro: ignore_Inl_equivp) |
|
3030 |
||
3031 |
lift_bnf 'a myoption (*<*)[wits: "Inl undefined :: 'a + 'a"](*>*) |
|
3032 |
||
71354
c71a44893645
eliminated one redundant proof obligation in lift_bnf for quotients
traytel
parents:
71264
diff
changeset
|
3033 |
proof - |
71264 | 3034 |
fix P :: "'a \<Rightarrow> 'b \<Rightarrow> bool" and Q :: "'b \<Rightarrow> 'c \<Rightarrow> bool" |
3035 |
assume "P OO Q \<noteq> bot" |
|
3036 |
then show "rel_sum P P OO ignore_Inl OO rel_sum Q Q |
|
3037 |
\<le> ignore_Inl OO rel_sum (P OO Q) (P OO Q) OO ignore_Inl" |
|
3038 |
by (fastforce(*<*) elim!: ignore_Inl.cases simp add: relcompp_apply fun_eq_iff rel_sum.simps(*>*)) |
|
3039 |
next |
|
3040 |
fix S :: "'a set set" |
|
3041 |
let ?eq = "{(x, x'). ignore_Inl x x'}" |
|
3042 |
let ?in = "\<lambda>A. {x. Basic_BNFs.setl x \<union> Basic_BNFs.setr x \<subseteq> A}" |
|
3043 |
assume "S \<noteq> {}" "\<Inter> S \<noteq> {}" |
|
3044 |
show "(\<Inter>A\<in>S. ?eq `` ?in A) \<subseteq> ?eq `` ?in (\<Inter> S)" |
|
3045 |
proof (intro subsetI) |
|
3046 |
fix x |
|
3047 |
assume "x \<in> (\<Inter>A\<in>S. ?eq `` ?in A)" |
|
3048 |
with \<open>\<Inter> S \<noteq> {}\<close> show "x \<in> ?eq `` ?in (\<Inter> S)" |
|
3049 |
by (cases x) (fastforce(*<*) dest!: spec[where x="Inl _"](*>*))+ |
|
3050 |
qed |
|
3051 |
(*<*)next |
|
3052 |
fix a :: 'a |
|
3053 |
assume "a \<in> (\<Inter>mx\<in>{mx. ignore_Inl (map_sum Inr Inr (Inl undefined)) mx}. |
|
3054 |
\<Union> (Basic_BNFs.setr ` (Basic_BNFs.setl mx \<union> Basic_BNFs.setr mx)))" |
|
3055 |
then show False |
|
3056 |
by (auto simp: setr.simps)(*>*) |
|
3057 |
qed |
|
3058 |
||
3059 |
||
62081 | 3060 |
text \<open> |
57542 | 3061 |
The next example declares a BNF axiomatically. This can be convenient for |
3062 |
reasoning abstractly about an arbitrary BNF. The @{command bnf_axiomatization} |
|
69505 | 3063 |
command below introduces a type \<open>('a, 'b, 'c) F\<close>, three set constants, |
62330 | 3064 |
a map function, a predicator, a relator, and a nonemptiness witness that depends only on |
69597 | 3065 |
\<^typ>\<open>'a\<close>. The type \<open>'a \<Rightarrow> ('a, 'b, 'c) F\<close> of the witness can be read |
3066 |
as an implication: Given a witness for \<^typ>\<open>'a\<close>, we can construct a witness for |
|
69505 | 3067 |
\<open>('a, 'b, 'c) F\<close>. The BNF properties are postulated as axioms. |
62081 | 3068 |
\<close> |
55350 | 3069 |
|
57542 | 3070 |
bnf_axiomatization (setA: 'a, setB: 'b, setC: 'c) F |
3071 |
[wits: "'a \<Rightarrow> ('a, 'b, 'c) F"] |
|
55350 | 3072 |
|
62731 | 3073 |
text \<open>\blankline\<close> |
55350 | 3074 |
|
3075 |
print_theorems |
|
3076 |
print_bnfs |
|
52794 | 3077 |
|
52824 | 3078 |
|
62731 | 3079 |
subsection \<open>Command Syntax |
3080 |
\label{ssec:bnf-command-syntax}\<close> |
|
3081 |
||
3082 |
subsubsection \<open>\keyw{bnf} |
|
3083 |
\label{sssec:bnf}\<close> |
|
62081 | 3084 |
|
3085 |
text \<open> |
|
53829 | 3086 |
\begin{matharray}{rcl} |
69505 | 3087 |
@{command_def "bnf"} & : & \<open>local_theory \<rightarrow> proof(prove)\<close> |
53829 | 3088 |
\end{matharray} |
3089 |
||
69597 | 3090 |
\<^rail>\<open> |
55474 | 3091 |
@@{command bnf} target? (name ':')? type \<newline> |
55029
61a6bf7d4b02
clarified @{rail} syntax: prefer explicit \<newline> symbol;
wenzelm
parents:
54958
diff
changeset
|
3092 |
'map:' term ('sets:' (term +))? 'bd:' term \<newline> |
58190 | 3093 |
('wits:' (term +))? ('rel:' term)? \<newline> |
62384 | 3094 |
('pred:' term)? @{syntax plugins}? |
69597 | 3095 |
\<close> |
55460
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
3096 |
|
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
3097 |
\medskip |
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
3098 |
|
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
3099 |
\noindent |
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
3100 |
The @{command bnf} command registers an existing type as a bounded natural |
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
3101 |
functor (BNF). The type must be equipped with an appropriate map function |
62330 | 3102 |
(functorial action). In addition, custom set functions, predicators, relators, and |
55460
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
3103 |
nonemptiness witnesses can be specified; otherwise, default versions are used. |
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
3104 |
|
55474 | 3105 |
The syntactic entity \synt{target} can be used to specify a local context, |
3106 |
\synt{type} denotes a HOL type, and \synt{term} denotes a HOL term |
|
76987 | 3107 |
\<^cite>\<open>"isabelle-isar-ref"\<close>. |
55474 | 3108 |
|
59280 | 3109 |
The @{syntax plugins} option indicates which plugins should be enabled |
69505 | 3110 |
(\<open>only\<close>) or disabled (\<open>del\<close>). By default, all plugins are enabled. |
59280 | 3111 |
|
55474 | 3112 |
%%% TODO: elaborate on proof obligations |
62081 | 3113 |
\<close> |
3114 |
||
62731 | 3115 |
subsubsection \<open>\keyw{lift_bnf} |
3116 |
\label{sssec:lift-bnf}\<close> |
|
62081 | 3117 |
|
3118 |
text \<open> |
|
60920 | 3119 |
\begin{matharray}{rcl} |
69505 | 3120 |
@{command_def "lift_bnf"} & : & \<open>local_theory \<rightarrow> proof(prove)\<close> |
60920 | 3121 |
\end{matharray} |
3122 |
||
69597 | 3123 |
\<^rail>\<open> |
60920 | 3124 |
@@{command lift_bnf} target? lb_options? \<newline> |
3125 |
@{syntax tyargs} name wit_terms? \<newline> |
|
71494 | 3126 |
('via' thm thm?)? @{syntax map_rel_pred}? |
60920 | 3127 |
; |
71264 | 3128 |
@{syntax_def lb_options}: '(' ((@{syntax plugins} | 'no_warn_wits' | 'no_warn_transfer') + ',') ')' |
60920 | 3129 |
; |
3130 |
@{syntax_def wit_terms}: '[' 'wits' ':' terms ']' |
|
69597 | 3131 |
\<close> |
61303 | 3132 |
\medskip |
3133 |
||
3134 |
\noindent |
|
3135 |
The @{command lift_bnf} command registers as a BNF an existing type (the |
|
3136 |
\emph{abstract type}) that was defined as a subtype of a BNF (the \emph{raw |
|
71264 | 3137 |
type}) using the @{command typedef} command or as a quotient type of a BNF (also, the |
3138 |
\emph{raw type}) using the @{command quotient_type}. To achieve this, it lifts the BNF |
|
3139 |
structure on the raw type to the abstract type following a \<^term>\<open>type_definition\<close> or a |
|
3140 |
\<^term>\<open>Quotient\<close> theorem. The theorem is usually inferred from the type, but can |
|
71494 | 3141 |
also be explicitly supplied by means of the optional \<open>via\<close> clause. In case of quotients, it |
3142 |
is sometimes also necessary to supply a second theorem of the form \<^term>\<open>reflp eq\<close>, |
|
3143 |
that expresses the reflexivity (and thus totality) of the equivalence relation. In |
|
62330 | 3144 |
addition, custom names for the set functions, the map function, the predicator, and the relator, |
61303 | 3145 |
as well as nonemptiness witnesses can be specified. |
3146 |
||
3147 |
Nonemptiness witnesses are not lifted from the raw type's BNF, as this would be |
|
3148 |
incomplete. They must be given as terms (on the raw type) and proved to be |
|
3149 |
witnesses. The command warns about witness types that are present in the raw |
|
3150 |
type's BNF but not supplied by the user. The warning can be disabled by |
|
69505 | 3151 |
specifying the \<open>no_warn_wits\<close> option. |
62081 | 3152 |
\<close> |
3153 |
||
62731 | 3154 |
subsubsection \<open>\keyw{copy_bnf} |
3155 |
\label{sssec:copy-bnf}\<close> |
|
62081 | 3156 |
|
3157 |
text \<open> |
|
61303 | 3158 |
\begin{matharray}{rcl} |
69505 | 3159 |
@{command_def "copy_bnf"} & : & \<open>local_theory \<rightarrow> local_theory\<close> |
61303 | 3160 |
\end{matharray} |
3161 |
||
69597 | 3162 |
\<^rail>\<open> |
71264 | 3163 |
@@{command copy_bnf} target? cb_options? \<newline> |
64939 | 3164 |
@{syntax tyargs} name ('via' thm)? @{syntax map_rel_pred}? |
71264 | 3165 |
; |
3166 |
@{syntax_def cb_options}: '(' ((@{syntax plugins} | 'no_warn_transfer') + ',') ')' |
|
3167 |
||
69597 | 3168 |
\<close> |
60920 | 3169 |
\medskip |
3170 |
||
3171 |
\noindent |
|
61303 | 3172 |
The @{command copy_bnf} command performs the same lifting as @{command lift_bnf} |
69597 | 3173 |
for type copies (@{command typedef}s with \<^term>\<open>UNIV\<close> as the representing set), |
61303 | 3174 |
without requiring the user to discharge any proof obligations or provide |
3175 |
nonemptiness witnesses. |
|
62081 | 3176 |
\<close> |
3177 |
||
62731 | 3178 |
subsubsection \<open>\keyw{bnf_axiomatization} |
3179 |
\label{sssec:bnf-axiomatization}\<close> |
|
62081 | 3180 |
|
3181 |
text \<open> |
|
54187 | 3182 |
\begin{matharray}{rcl} |
69505 | 3183 |
@{command_def "bnf_axiomatization"} & : & \<open>local_theory \<rightarrow> local_theory\<close> |
54187 | 3184 |
\end{matharray} |
3185 |
||
69597 | 3186 |
\<^rail>\<open> |
59280 | 3187 |
@@{command bnf_axiomatization} target? ('(' @{syntax plugins} ')')? \<newline> |
58190 | 3188 |
@{syntax tyargs}? name @{syntax wit_types}? \<newline> |
64939 | 3189 |
mixfix? @{syntax map_rel_pred}? |
54602 | 3190 |
; |
55350 | 3191 |
@{syntax_def wit_types}: '[' 'wits' ':' types ']' |
69597 | 3192 |
\<close> |
54602 | 3193 |
|
55351 | 3194 |
\medskip |
3195 |
||
55350 | 3196 |
\noindent |
56942 | 3197 |
The @{command bnf_axiomatization} command declares a new type and associated constants |
62330 | 3198 |
(map, set, predicator, relator, and cardinal bound) and asserts the BNF properties for |
55460
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
3199 |
these constants as axioms. |
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
3200 |
|
55474 | 3201 |
The syntactic entity \synt{target} can be used to specify a local context, |
3202 |
\synt{name} denotes an identifier, \synt{typefree} denotes fixed type variable |
|
69597 | 3203 |
(\<^typ>\<open>'a\<close>, \<^typ>\<open>'b\<close>, \ldots), \synt{mixfix} denotes the usual parenthesized |
62747 | 3204 |
mixfix notation, and \synt{types} denotes a space-separated list of types |
76987 | 3205 |
\<^cite>\<open>"isabelle-isar-ref"\<close>. |
55460
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
3206 |
|
59280 | 3207 |
The @{syntax plugins} option indicates which plugins should be enabled |
69505 | 3208 |
(\<open>only\<close>) or disabled (\<open>del\<close>). By default, all plugins are enabled. |
59280 | 3209 |
|
55460
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
3210 |
Type arguments are live by default; they can be marked as dead by entering |
69505 | 3211 |
\<open>dead\<close> in front of the type variable (e.g., \<open>(dead 'a)\<close>) |
57092 | 3212 |
instead of an identifier for the corresponding set function. Witnesses can be |
3213 |
specified by their types. Otherwise, the syntax of @{command bnf_axiomatization} |
|
58310 | 3214 |
is identical to the left-hand side of a @{command datatype} or |
57092 | 3215 |
@{command codatatype} definition. |
55350 | 3216 |
|
3217 |
The command is useful to reason abstractly about BNFs. The axioms are safe |
|
57575 | 3218 |
because there exist BNFs of arbitrary large arities. Applications must import |
63680 | 3219 |
the \<^file>\<open>~~/src/HOL/Library/BNF_Axiomatization.thy\<close> theory |
61304 | 3220 |
to use this functionality. |
62081 | 3221 |
\<close> |
3222 |
||
3223 |
||
62731 | 3224 |
subsubsection \<open>\keyw{print_bnfs} |
3225 |
\label{sssec:print-bnfs}\<close> |
|
62081 | 3226 |
|
3227 |
text \<open> |
|
53829 | 3228 |
\begin{matharray}{rcl} |
69505 | 3229 |
@{command_def "print_bnfs"} & : & \<open>local_theory \<rightarrow>\<close> |
53829 | 3230 |
\end{matharray} |
3231 |
||
69597 | 3232 |
\<^rail>\<open> |
53829 | 3233 |
@@{command print_bnfs} |
69597 | 3234 |
\<close> |
62081 | 3235 |
\<close> |
3236 |
||
3237 |
||
71763
3b36fc4916af
removed LaTeX package and hack to avoid ALLCAPS headers
blanchet
parents:
71494
diff
changeset
|
3238 |
section \<open>Deriving Destructors and Constructor Theorems |
3b36fc4916af
removed LaTeX package and hack to avoid ALLCAPS headers
blanchet
parents:
71494
diff
changeset
|
3239 |
\label{sec:deriving-destructors-and-constructor-theorems}\<close> |
62081 | 3240 |
|
3241 |
text \<open> |
|
53623 | 3242 |
The derivation of convenience theorems for types equipped with free constructors, |
58310 | 3243 |
as performed internally by @{command datatype} and @{command codatatype}, |
55468
98b25c51e9e5
renamed 'wrap_free_constructors' to 'free_constructors' (cf. 'functor', 'bnf', etc.)
blanchet
parents:
55460
diff
changeset
|
3244 |
is available as a stand-alone command called @{command free_constructors}. |
52794 | 3245 |
|
53617 | 3246 |
% * need for this is rare but may arise if you want e.g. to add destructors to |
3247 |
% a type not introduced by ... |
|
3248 |
% |
|
55468
98b25c51e9e5
renamed 'wrap_free_constructors' to 'free_constructors' (cf. 'functor', 'bnf', etc.)
blanchet
parents:
55460
diff
changeset
|
3249 |
% * @{command free_constructors} |
69505 | 3250 |
% * \<open>plugins\<close>, \<open>discs_sels\<close> |
53617 | 3251 |
% * hack to have both co and nonco view via locale (cf. ext nats) |
62081 | 3252 |
\<close> |
52792 | 3253 |
|
52824 | 3254 |
|
53619 | 3255 |
(* |
62731 | 3256 |
subsection \<open>Introductory Example |
3257 |
\label{ssec:ctors-introductory-example}\<close> |
|
53619 | 3258 |
*) |
52794 | 3259 |
|
52824 | 3260 |
|
62731 | 3261 |
subsection \<open>Command Syntax |
3262 |
\label{ssec:ctors-command-syntax}\<close> |
|
3263 |
||
3264 |
subsubsection \<open>\keyw{free_constructors} |
|
3265 |
\label{sssec:free-constructors}\<close> |
|
62081 | 3266 |
|
3267 |
text \<open> |
|
53829 | 3268 |
\begin{matharray}{rcl} |
69505 | 3269 |
@{command_def "free_constructors"} & : & \<open>local_theory \<rightarrow> proof(prove)\<close> |
53829 | 3270 |
\end{matharray} |
53018 | 3271 |
|
69597 | 3272 |
\<^rail>\<open> |
55468
98b25c51e9e5
renamed 'wrap_free_constructors' to 'free_constructors' (cf. 'functor', 'bnf', etc.)
blanchet
parents:
55460
diff
changeset
|
3273 |
@@{command free_constructors} target? @{syntax dt_options} \<newline> |
57200
aab87ffa60cc
use 'where' clause for selector default value syntax
blanchet
parents:
57153
diff
changeset
|
3274 |
name 'for' (@{syntax fc_ctor} + '|') \<newline> |
57206
d9be905d6283
changed syntax of map: and rel: arguments to BNF-based datatypes
blanchet
parents:
57200
diff
changeset
|
3275 |
(@'where' (prop + '|'))? |
53018 | 3276 |
; |
57200
aab87ffa60cc
use 'where' clause for selector default value syntax
blanchet
parents:
57153
diff
changeset
|
3277 |
@{syntax_def fc_ctor}: (name ':')? term (name * ) |
69597 | 3278 |
\<close> |
53018 | 3279 |
|
55351 | 3280 |
\medskip |
3281 |
||
55460
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
3282 |
\noindent |
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
3283 |
The @{command free_constructors} command generates destructor constants for |
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
3284 |
freely constructed types as well as properties about constructors and |
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
3285 |
destructors. It also registers the constants and theorems in a data structure |
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
3286 |
that is queried by various tools (e.g., \keyw{function}). |
3f4efd7d950d
added a bit of documentation for the different commands
blanchet
parents:
55459
diff
changeset
|
3287 |
|
55474 | 3288 |
The syntactic entity \synt{target} can be used to specify a local context, |
57200
aab87ffa60cc
use 'where' clause for selector default value syntax
blanchet
parents:
57153
diff
changeset
|
3289 |
\synt{name} denotes an identifier, \synt{prop} denotes a HOL proposition, and |
76987 | 3290 |
\synt{term} denotes a HOL term \<^cite>\<open>"isabelle-isar-ref"\<close>. |
55474 | 3291 |
|
58310 | 3292 |
The syntax resembles that of @{command datatype} and @{command codatatype} |
55474 | 3293 |
definitions (Sections |
3294 |
\ref{ssec:datatype-command-syntax}~and~\ref{ssec:codatatype-command-syntax}). |
|
3295 |
A constructor is specified by an optional name for the discriminator, the |
|
3296 |
constructor itself (as a term), and a list of optional names for the selectors. |
|
53028 | 3297 |
|
53542 | 3298 |
Section~\ref{ssec:datatype-generated-theorems} lists the generated theorems. |
69505 | 3299 |
For bootstrapping reasons, the generally useful \<open>[fundef_cong]\<close> |
3300 |
attribute is not set on the generated \<open>case_cong\<close> theorem. It can be |
|
57542 | 3301 |
added manually using \keyw{declare}. |
62081 | 3302 |
\<close> |
3303 |
||
3304 |
||
62731 | 3305 |
subsubsection \<open>\keyw{simps_of_case} |
3306 |
\label{sssec:simps-of-case}\<close> |
|
62081 | 3307 |
|
3308 |
text \<open> |
|
3309 |
\begin{matharray}{rcl} |
|
69505 | 3310 |
@{command_def "simps_of_case"} & : & \<open>local_theory \<rightarrow> local_theory\<close> |
62081 | 3311 |
\end{matharray} |
3312 |
||
69597 | 3313 |
\<^rail>\<open> |
62081 | 3314 |
@@{command simps_of_case} target? (name ':')? \<newline> |
62969 | 3315 |
(thm + ) (@'splits' ':' (thm + ))? |
69597 | 3316 |
\<close> |
62081 | 3317 |
|
3318 |
\medskip |
|
3319 |
||
3320 |
\noindent |
|
3321 |
The @{command simps_of_case} command provided by theory |
|
63680 | 3322 |
\<^file>\<open>~~/src/HOL/Library/Simps_Case_Conv.thy\<close> converts a single equation with |
62081 | 3323 |
a complex case expression on the right-hand side into a set of pattern-matching |
3324 |
equations. For example, |
|
3325 |
\<close> |
|
3326 |
||
3327 |
(*<*) |
|
3328 |
context late |
|
3329 |
begin |
|
3330 |
(*>*) |
|
3331 |
simps_of_case lapp_simps: lapp.code |
|
3332 |
||
3333 |
text \<open> |
|
3334 |
\noindent |
|
3335 |
translates @{thm lapp.code[no_vars]} into |
|
3336 |
% |
|
3337 |
\begin{gather*} |
|
3338 |
@{thm lapp_simps(1)[no_vars]} \\ |
|
3339 |
@{thm lapp_simps(2)[no_vars]} |
|
3340 |
\end{gather*} |
|
3341 |
\<close> |
|
3342 |
||
3343 |
||
62731 | 3344 |
subsubsection \<open>\keyw{case_of_simps} |
3345 |
\label{sssec:case-of-simps}\<close> |
|
62081 | 3346 |
|
3347 |
text \<open> |
|
3348 |
\begin{matharray}{rcl} |
|
69505 | 3349 |
@{command_def "case_of_simps"} & : & \<open>local_theory \<rightarrow> local_theory\<close> |
62081 | 3350 |
\end{matharray} |
3351 |
||
69597 | 3352 |
\<^rail>\<open> |
62081 | 3353 |
@@{command case_of_simps} target? (name ':')? \<newline> |
62969 | 3354 |
(thm + ) |
69597 | 3355 |
\<close> |
62081 | 3356 |
|
3357 |
\medskip |
|
3358 |
||
3359 |
\noindent |
|
3360 |
The \keyw{case_of_simps} command provided by theory |
|
63680 | 3361 |
\<^file>\<open>~~/src/HOL/Library/Simps_Case_Conv.thy\<close> converts a set of |
62081 | 3362 |
pattern-matching equations into single equation with a complex case expression |
3363 |
on the right-hand side (cf.\ @{command simps_of_case}). For example, |
|
3364 |
\<close> |
|
3365 |
||
3366 |
case_of_simps lapp_case: lapp_simps |
|
3367 |
||
3368 |
text \<open> |
|
3369 |
\noindent |
|
3370 |
translates |
|
3371 |
% |
|
3372 |
\begin{gather*} |
|
3373 |
@{thm lapp_simps(1)[no_vars]} \\ |
|
3374 |
@{thm lapp_simps(2)[no_vars]} |
|
3375 |
\end{gather*} |
|
3376 |
% |
|
3377 |
into @{thm lapp_case[no_vars]}. |
|
3378 |
\<close> |
|
3379 |
(*<*) |
|
3380 |
end |
|
3381 |
(*>*) |
|
52828 | 3382 |
|
52794 | 3383 |
|
53617 | 3384 |
(* |
62731 | 3385 |
section \<open>Using the Standard ML Interface |
3386 |
\label{sec:using-the-standard-ml-interface}\<close> |
|
62081 | 3387 |
|
3388 |
text \<open> |
|
53623 | 3389 |
The package's programmatic interface. |
62081 | 3390 |
\<close> |
53617 | 3391 |
*) |
52794 | 3392 |
|
3393 |
||
62731 | 3394 |
section \<open>Selecting Plugins |
3395 |
\label{sec:selecting-plugins}\<close> |
|
62081 | 3396 |
|
3397 |
text \<open> |
|
58190 | 3398 |
Plugins extend the (co)datatype package to interoperate with other Isabelle |
58192 | 3399 |
packages and tools, such as the code generator, Transfer, Lifting, and |
3400 |
Quickcheck. They can be enabled or disabled individually using the |
|
58310 | 3401 |
@{syntax plugins} option to the commands @{command datatype}, |
59300 | 3402 |
@{command primrec}, @{command codatatype}, @{command primcorec}, |
3403 |
@{command primcorecursive}, @{command bnf}, @{command bnf_axiomatization}, and |
|
3404 |
@{command free_constructors}. For example: |
|
62081 | 3405 |
\<close> |
58190 | 3406 |
|
58659
6c9821c32dd5
Local_Interpretation is superseded by Plugin with formal Plugin_Name management, avoiding undeclared strings;
wenzelm
parents:
58620
diff
changeset
|
3407 |
datatype (plugins del: code "quickcheck") color = Red | Black |
58192 | 3408 |
|
62081 | 3409 |
text \<open> |
61788 | 3410 |
Beyond the standard plugins, the \emph{Archive of Formal Proofs} includes a |
3411 |
\keyw{derive} command that derives class instances of datatypes |
|
76987 | 3412 |
\<^cite>\<open>"sternagel-thiemann-2015"\<close>. |
62081 | 3413 |
\<close> |
3414 |
||
62731 | 3415 |
subsection \<open>Code Generator |
3416 |
\label{ssec:code-generator}\<close> |
|
62081 | 3417 |
|
3418 |
text \<open> |
|
59299 | 3419 |
The \hthm{code} plugin registers freely generated types, including |
3420 |
(co)datatypes, and (co)recursive functions for code generation. No distinction |
|
3421 |
is made between datatypes and codatatypes. This means that for target languages |
|
3422 |
with a strict evaluation strategy (e.g., Standard ML), programs that attempt to |
|
3423 |
produce infinite codatatype values will not terminate. |
|
3424 |
||
3425 |
For types, the plugin derives the following properties: |
|
58244 | 3426 |
|
3427 |
\begin{indentblock} |
|
3428 |
\begin{description} |
|
3429 |
||
69505 | 3430 |
\item[\<open>t.\<close>\hthm{eq.refl} \<open>[code nbe]\<close>\rm:] ~ \\ |
58244 | 3431 |
@{thm list.eq.refl[no_vars]} |
3432 |
||
69505 | 3433 |
\item[\<open>t.\<close>\hthm{eq.simps} \<open>[code]\<close>\rm:] ~ \\ |
58244 | 3434 |
@{thm list.eq.simps(1)[no_vars]} \\ |
3435 |
@{thm list.eq.simps(2)[no_vars]} \\ |
|
3436 |
@{thm list.eq.simps(3)[no_vars]} \\ |
|
3437 |
@{thm list.eq.simps(4)[no_vars]} \\ |
|
3438 |
@{thm list.eq.simps(5)[no_vars]} \\ |
|
3439 |
@{thm list.eq.simps(6)[no_vars]} |
|
3440 |
||
3441 |
\end{description} |
|
3442 |
\end{indentblock} |
|
58509 | 3443 |
|
69505 | 3444 |
In addition, the plugin sets the \<open>[code]\<close> attribute on a number of |
59299 | 3445 |
properties of freely generated types and of (co)recursive functions, as |
3446 |
documented in Sections \ref{ssec:datatype-generated-theorems}, |
|
3447 |
\ref{ssec:primrec-generated-theorems}, \ref{ssec:codatatype-generated-theorems}, |
|
3448 |
and~\ref{ssec:primcorec-generated-theorems}. |
|
62081 | 3449 |
\<close> |
3450 |
||
3451 |
||
62731 | 3452 |
subsection \<open>Size |
3453 |
\label{ssec:size}\<close> |
|
62081 | 3454 |
|
3455 |
text \<open> |
|
69505 | 3456 |
For each datatype \<open>t\<close>, the \hthm{size} plugin generates a generic size |
3457 |
function \<open>t.size_t\<close> as well as a specific instance |
|
3458 |
\<open>size :: t \<Rightarrow> nat\<close> belonging to the \<open>size\<close> type class. The |
|
69597 | 3459 |
\keyw{fun} command relies on \<^const>\<open>size\<close> to prove termination of recursive |
61787 | 3460 |
functions on datatypes. |
58190 | 3461 |
|
3462 |
The plugin derives the following properties: |
|
3463 |
||
3464 |
\begin{indentblock} |
|
3465 |
\begin{description} |
|
3466 |
||
69505 | 3467 |
\item[\<open>t.\<close>\hthm{size} \<open>[simp, code]\<close>\rm:] ~ \\ |
58190 | 3468 |
@{thm list.size(1)[no_vars]} \\ |
3469 |
@{thm list.size(2)[no_vars]} \\ |
|
3470 |
@{thm list.size(3)[no_vars]} \\ |
|
3471 |
@{thm list.size(4)[no_vars]} |
|
3472 |
||
69505 | 3473 |
\item[\<open>t.\<close>\hthm{size_gen}\rm:] ~ \\ |
58737 | 3474 |
@{thm list.size_gen(1)[no_vars]} \\ |
3475 |
@{thm list.size_gen(2)[no_vars]} |
|
3476 |
||
69505 | 3477 |
\item[\<open>t.\<close>\hthm{size_gen_o_map}\rm:] ~ \\ |
58739 | 3478 |
@{thm list.size_gen_o_map[no_vars]} |
58190 | 3479 |
|
69505 | 3480 |
\item[\<open>t.\<close>\hthm{size_neq}\rm:] ~ \\ |
69597 | 3481 |
This property is missing for \<^typ>\<open>'a list\<close>. If the \<^term>\<open>size\<close> function |
60134 | 3482 |
always evaluates to a non-zero value, this theorem has the form |
69597 | 3483 |
\<^prop>\<open>\<not> size x = 0\<close>. |
58914 | 3484 |
|
58190 | 3485 |
\end{description} |
3486 |
\end{indentblock} |
|
61787 | 3487 |
|
69505 | 3488 |
The \<open>t.size\<close> and \<open>t.size_t\<close> functions generated for datatypes |
3489 |
defined by nested recursion through a datatype \<open>u\<close> depend on |
|
3490 |
\<open>u.size_u\<close>. |
|
3491 |
||
3492 |
If the recursion is through a non-datatype \<open>u\<close> with type arguments |
|
3493 |
\<open>'a\<^sub>1, \<dots>, 'a\<^sub>m\<close>, by default \<open>u\<close> values are given a size of 0. This |
|
61787 | 3494 |
can be improved upon by registering a custom size function of type |
69505 | 3495 |
\<open>('a\<^sub>1 \<Rightarrow> nat) \<Rightarrow> \<dots> \<Rightarrow> ('a\<^sub>m \<Rightarrow> nat) \<Rightarrow> u \<Rightarrow> nat\<close> using |
69597 | 3496 |
the ML function \<^ML>\<open>BNF_LFP_Size.register_size\<close> or |
3497 |
\<^ML>\<open>BNF_LFP_Size.register_size_global\<close>. See theory |
|
63680 | 3498 |
\<^file>\<open>~~/src/HOL/Library/Multiset.thy\<close> for an example. |
62081 | 3499 |
\<close> |
3500 |
||
3501 |
||
62731 | 3502 |
subsection \<open>Transfer |
3503 |
\label{ssec:transfer}\<close> |
|
62081 | 3504 |
|
3505 |
text \<open> |
|
58192 | 3506 |
For each (co)datatype with live type arguments and each manually registered BNF, |
69505 | 3507 |
the \hthm{transfer} plugin generates a predicator \<open>t.pred_t\<close> and |
58244 | 3508 |
properties that guide the Transfer tool. |
3509 |
||
61349 | 3510 |
For types with at least one live type argument and \emph{no dead type |
3511 |
arguments}, the plugin derives the following properties: |
|
58244 | 3512 |
|
3513 |
\begin{indentblock} |
|
3514 |
\begin{description} |
|
3515 |
||
69505 | 3516 |
\item[\<open>t.\<close>\hthm{Domainp_rel} \<open>[relator_domain]\<close>\rm:] ~ \\ |
58244 | 3517 |
@{thm list.Domainp_rel[no_vars]} |
3518 |
||
69505 | 3519 |
\item[\<open>t.\<close>\hthm{left_total_rel} \<open>[transfer_rule]\<close>\rm:] ~ \\ |
58244 | 3520 |
@{thm list.left_total_rel[no_vars]} |
3521 |
||
69505 | 3522 |
\item[\<open>t.\<close>\hthm{left_unique_rel} \<open>[transfer_rule]\<close>\rm:] ~ \\ |
58244 | 3523 |
@{thm list.left_unique_rel[no_vars]} |
3524 |
||
69505 | 3525 |
\item[\<open>t.\<close>\hthm{right_total_rel} \<open>[transfer_rule]\<close>\rm:] ~ \\ |
58244 | 3526 |
@{thm list.right_total_rel[no_vars]} |
3527 |
||
69505 | 3528 |
\item[\<open>t.\<close>\hthm{right_unique_rel} \<open>[transfer_rule]\<close>\rm:] ~ \\ |
58244 | 3529 |
@{thm list.right_unique_rel[no_vars]} |
3530 |
||
69505 | 3531 |
\item[\<open>t.\<close>\hthm{bi_total_rel} \<open>[transfer_rule]\<close>\rm:] ~ \\ |
58244 | 3532 |
@{thm list.bi_total_rel[no_vars]} |
3533 |
||
69505 | 3534 |
\item[\<open>t.\<close>\hthm{bi_unique_rel} \<open>[transfer_rule]\<close>\rm:] ~ \\ |
58244 | 3535 |
@{thm list.bi_unique_rel[no_vars]} |
3536 |
||
3537 |
\end{description} |
|
3538 |
\end{indentblock} |
|
59282 | 3539 |
|
61349 | 3540 |
For (co)datatypes with at least one live type argument, the plugin sets the |
69505 | 3541 |
\<open>[transfer_rule]\<close> attribute on the following (co)datatypes properties: |
3542 |
\<open>t.case_\<close>\allowbreak \<open>transfer\<close>, |
|
3543 |
\<open>t.sel_\<close>\allowbreak \<open>transfer\<close>, |
|
3544 |
\<open>t.ctr_\<close>\allowbreak \<open>transfer\<close>, |
|
3545 |
\<open>t.disc_\<close>\allowbreak \<open>transfer\<close>, |
|
3546 |
\<open>t.rec_\<close>\allowbreak \<open>transfer\<close>, and |
|
3547 |
\<open>t.corec_\<close>\allowbreak \<open>transfer\<close>. |
|
61788 | 3548 |
For (co)datatypes that further have \emph{no dead type arguments}, the plugin |
69505 | 3549 |
sets \<open>[transfer_rule]\<close> on |
3550 |
\<open>t.set_\<close>\allowbreak \<open>transfer\<close>, |
|
3551 |
\<open>t.map_\<close>\allowbreak \<open>transfer\<close>, and |
|
3552 |
\<open>t.rel_\<close>\allowbreak \<open>transfer\<close>. |
|
59579 | 3553 |
|
59282 | 3554 |
For @{command primrec}, @{command primcorec}, and @{command primcorecursive}, |
69505 | 3555 |
the plugin implements the generation of the \<open>f.transfer\<close> property, |
3556 |
conditioned by the \<open>transfer\<close> option, and sets the |
|
3557 |
\<open>[transfer_rule]\<close> attribute on these. |
|
62081 | 3558 |
\<close> |
3559 |
||
3560 |
||
62731 | 3561 |
subsection \<open>Lifting |
3562 |
\label{ssec:lifting}\<close> |
|
62081 | 3563 |
|
3564 |
text \<open> |
|
59721 | 3565 |
For each (co)datatype and each manually registered BNF with at least one live |
61349 | 3566 |
type argument \emph{and no dead type arguments}, the \hthm{lifting} plugin |
3567 |
generates properties and attributes that guide the Lifting tool. |
|
58244 | 3568 |
|
3569 |
The plugin derives the following property: |
|
3570 |
||
3571 |
\begin{indentblock} |
|
3572 |
\begin{description} |
|
3573 |
||
69505 | 3574 |
\item[\<open>t.\<close>\hthm{Quotient} \<open>[quot_map]\<close>\rm:] ~ \\ |
58244 | 3575 |
@{thm list.Quotient[no_vars]} |
3576 |
||
3577 |
\end{description} |
|
3578 |
\end{indentblock} |
|
3579 |
||
69505 | 3580 |
In addition, the plugin sets the \<open>[relator_eq]\<close> attribute on a |
3581 |
variant of the \<open>t.rel_eq_onp\<close> property, the \<open>[relator_mono]\<close> |
|
3582 |
attribute on \<open>t.rel_mono\<close>, and the \<open>[relator_distr]\<close> attribute |
|
3583 |
on \<open>t.rel_compp\<close>. |
|
62081 | 3584 |
\<close> |
3585 |
||
3586 |
||
62731 | 3587 |
subsection \<open>Quickcheck |
3588 |
\label{ssec:quickcheck}\<close> |
|
62081 | 3589 |
|
3590 |
text \<open> |
|
59280 | 3591 |
The integration of datatypes with Quickcheck is accomplished by the |
59282 | 3592 |
\hthm{quick\-check} plugin. It combines a number of subplugins that instantiate |
59280 | 3593 |
specific type classes. The subplugins can be enabled or disabled individually. |
3594 |
They are listed below: |
|
58245 | 3595 |
|
3596 |
\begin{indentblock} |
|
3597 |
\hthm{quickcheck_random} \\ |
|
3598 |
\hthm{quickcheck_exhaustive} \\ |
|
3599 |
\hthm{quickcheck_bounded_forall} \\ |
|
3600 |
\hthm{quickcheck_full_exhaustive} \\ |
|
3601 |
\hthm{quickcheck_narrowing} |
|
3602 |
\end{indentblock} |
|
62081 | 3603 |
\<close> |
3604 |
||
3605 |
||
62731 | 3606 |
subsection \<open>Program Extraction |
3607 |
\label{ssec:program-extraction}\<close> |
|
62081 | 3608 |
|
3609 |
text \<open> |
|
58278 | 3610 |
The \hthm{extraction} plugin provides realizers for induction and case analysis, |
3611 |
to enable program extraction from proofs involving datatypes. This functionality |
|
58395 | 3612 |
is only available with full proof objects, i.e., with the \emph{HOL-Proofs} |
58278 | 3613 |
session. |
62081 | 3614 |
\<close> |
3615 |
||
3616 |
||
62731 | 3617 |
section \<open>Known Bugs and Limitations |
3618 |
\label{sec:known-bugs-and-limitations}\<close> |
|
62081 | 3619 |
|
3620 |
text \<open> |
|
62731 | 3621 |
This section lists the known bugs and limitations of the (co)datatype package at |
3622 |
the time of this writing. |
|
58395 | 3623 |
|
3624 |
\begin{enumerate} |
|
3625 |
\setlength{\itemsep}{0pt} |
|
3626 |
||
3627 |
\item |
|
62317 | 3628 |
\emph{Defining mutually (co)recursive (co)datatypes can be slow.} Fortunately, |
58395 | 3629 |
it is always possible to recast mutual specifications to nested ones, which are |
3630 |
processed more efficiently. |
|
3631 |
||
3632 |
\item |
|
60736 | 3633 |
\emph{Locally fixed types and terms cannot be used in type specifications.} |
3634 |
The limitation on types can be circumvented by adding type arguments to the local |
|
58395 | 3635 |
(co)datatypes to abstract over the locally fixed types. |
3636 |
||
3637 |
\item |
|
3638 |
\emph{The \emph{\keyw{primcorec}} command does not allow user-specified names and |
|
3639 |
attributes next to the entered formulas.} The less convenient syntax, using the |
|
3640 |
\keyw{lemmas} command, is available as an alternative. |
|
3641 |
||
3642 |
\item |
|
62317 | 3643 |
\emph{The \emph{\keyw{primcorec}} command does not allow corecursion under |
69505 | 3644 |
\<open>case\<close>--\<open>of\<close> for datatypes that are defined without |
62331 | 3645 |
discriminators and selectors.} |
62317 | 3646 |
|
3647 |
\item |
|
58395 | 3648 |
\emph{There is no way to use an overloaded constant from a syntactic type |
69505 | 3649 |
class, such as \<open>0\<close>, as a constructor.} |
58395 | 3650 |
|
3651 |
\item |
|
3652 |
\emph{There is no way to register the same type as both a datatype and a |
|
3653 |
codatatype.} This affects types such as the extended natural numbers, for which |
|
3654 |
both views would make sense (for a different set of constructors). |
|
3655 |
||
3656 |
\item |
|
3657 |
\emph{The names of variables are often suboptimal in the properties generated by |
|
3658 |
the package.} |
|
3659 |
||
60146 | 3660 |
\item |
3661 |
\emph{The compatibility layer sometimes produces induction principles with a |
|
61788 | 3662 |
slightly different ordering of the premises than the old package.} |
60146 | 3663 |
|
58395 | 3664 |
\end{enumerate} |
62081 | 3665 |
\<close> |
3666 |
||
3667 |
||
3668 |
text \<open> |
|
53863
c7364dca96f2
textual improvements following Christian Sternagel's feedback
blanchet
parents:
53857
diff
changeset
|
3669 |
\section*{Acknowledgment} |
c7364dca96f2
textual improvements following Christian Sternagel's feedback
blanchet
parents:
53857
diff
changeset
|
3670 |
|
53749
b37db925b663
adapted primcorec documentation to reflect the three views
blanchet
parents:
53748
diff
changeset
|
3671 |
Tobias Nipkow and Makarius Wenzel encouraged us to implement the new |
53617 | 3672 |
(co)datatype package. Andreas Lochbihler provided lots of comments on earlier |
56655 | 3673 |
versions of the package, especially on the coinductive part. Brian Huffman |
58245 | 3674 |
suggested major simplifications to the internal constructions. Ond\v{r}ej |
69505 | 3675 |
Kun\v{c}ar implemented the \<open>transfer\<close> and \<open>lifting\<close> plugins. |
60137 | 3676 |
Christian Sternagel and Ren\'e Thiemann ported the \keyw{derive} command |
62081 | 3677 |
from the \emph{Archive of Formal Proofs} to the new datatypes. Gerwin Klein and |
3678 |
Lars Noschinski implemented the @{command simps_of_case} and @{command |
|
3679 |
case_of_simps} commands. Florian Haftmann, Christian Urban, and Makarius |
|
3680 |
Wenzel provided general advice on Isabelle and package writing. Stefan Milius |
|
76063 | 3681 |
and Lutz Schröder found an elegant proof that eliminated one of the BNF |
62081 | 3682 |
proof obligations. Mamoun Filali-Amine, Gerwin Klein, Andreas Lochbihler, |
3683 |
Tobias Nipkow, and Christian Sternagel suggested many textual improvements to |
|
3684 |
this tutorial. |
|
3685 |
\<close> |
|
53617 | 3686 |
|
52792 | 3687 |
end |