Mercurial > cpdt > repo

annotate src/Subset.v @ 392:4b1242b277b2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Typo fixes
author Adam Chlipala <adam@chlipala.net>
date Fri, 20 Apr 2012 12:49:47 -0400
parents 31fa03bc0f18
children 05efde66559d
rev   line source
adam@380 1 (* Copyright (c) 2008-2012, Adam Chlipala
adamc@70 2 *
adamc@70 3 * This work is licensed under a
adamc@70 4 * Creative Commons Attribution-Noncommercial-No Derivative Works 3.0
adamc@70 5 * Unported License.
adamc@70 6 * The license text is available at:
adamc@70 7 * http://creativecommons.org/licenses/by-nc-nd/3.0/
adamc@70 8 *)
adamc@70 9
adamc@70 10 (* begin hide *)
adamc@70 11 Require Import List.
adamc@70 12
adam@314 13 Require Import CpdtTactics.
adamc@70 14
adamc@70 15 Set Implicit Arguments.
adamc@70 16 (* end hide *)
adamc@70 17
adamc@70 18
adamc@74 19 (** %\part{Programming with Dependent Types}
adamc@74 20
adamc@74 21 \chapter{Subset Types and Variations}% *)
adamc@70 22
adam@335 23 (** So far, we have seen many examples of what we might call %``%#"#classical program verification.#"#%''% We write programs, write their specifications, and then prove that the programs satisfy their specifications. The programs that we have written in Coq have been normal functional programs that we could just as well have written in Haskell or ML. In this chapter, we start investigating uses of %\index{dependent types}\textit{%#<i>#dependent types#</i>#%}% to integrate programming, specification, and proving into a single phase. The techniques we will learn make it possible to reduce the cost of program verification dramatically. *)
adamc@70 24
adamc@70 25
adamc@70 26 (** * Introducing Subset Types *)
adamc@70 27
adamc@70 28 (** Let us consider several ways of implementing the natural number predecessor function. We start by displaying the definition from the standard library: *)
adamc@70 29
adamc@70 30 Print pred.
adamc@212 31 (** %\vspace{-.15in}% [[
adamc@70 32 pred = fun n : nat => match n with
adamc@70 33 | 0 => 0
adamc@70 34 | S u => u
adamc@70 35 end
adamc@70 36 : nat -> nat
adamc@212 37
adamc@212 38 ]]
adamc@70 39
adam@335 40 We can use a new command, %\index{Vernacular commands!Extraction}\index{program extraction}\index{extraction|see{program extraction}}%[Extraction], to produce an %\index{OCaml}%OCaml version of this function. *)
adamc@70 41
adamc@70 42 Extraction pred.
adamc@70 43
adamc@70 44 (** %\begin{verbatim}
adamc@70 45 (** val pred : nat -> nat **)
adamc@70 46
adamc@70 47 let pred = function
adamc@70 48 | O -> O
adamc@70 49 | S u -> u
adamc@70 50 \end{verbatim}%
adamc@70 51
adamc@70 52 #<pre>
adamc@70 53 (** val pred : nat -> nat **)
adamc@70 54
adamc@70 55 let pred = function
adamc@70 56 | O -> O
adamc@70 57 | S u -> u
adamc@70 58 </pre># *)
adamc@70 59
adamc@70 60 (** Returning 0 as the predecessor of 0 can come across as somewhat of a hack. In some situations, we might like to be sure that we never try to take the predecessor of 0. We can enforce this by giving [pred] a stronger, dependent type. *)
adamc@70 61
adamc@70 62 Lemma zgtz : 0 > 0 -> False.
adamc@70 63 crush.
adamc@70 64 Qed.
adamc@70 65
adamc@70 66 Definition pred_strong1 (n : nat) : n > 0 -> nat :=
adamc@212 67 match n with
adamc@70 68 | O => fun pf : 0 > 0 => match zgtz pf with end
adamc@70 69 | S n' => fun _ => n'
adamc@70 70 end.
adamc@70 71
adamc@70 72 (** We expand the type of [pred] to include a %\textit{%#<i>#proof#</i>#%}% that its argument [n] is greater than 0. When [n] is 0, we use the proof to derive a contradiction, which we can use to build a value of any type via a vacuous pattern match. When [n] is a successor, we have no need for the proof and just return the answer. The proof argument can be said to have a %\textit{%#<i>#dependent#</i>#%}% type, because its type depends on the %\textit{%#<i>#value#</i>#%}% of the argument [n].
adamc@70 73
adam@282 74 Coq's [Eval] command can execute particular invocations of [pred_strong1] just as easily as it can execute more traditional functional programs. Note that Coq has decided that argument [n] of [pred_strong1] can be made %\textit{%#<i>#implicit#</i>#%}%, since it can be deduced from the type of the second argument, so we need not write [n] in function calls. *)
adam@282 75
adam@282 76 Theorem two_gt0 : 2 > 0.
adam@282 77 crush.
adam@282 78 Qed.
adam@282 79
adam@282 80 Eval compute in pred_strong1 two_gt0.
adam@282 81 (** %\vspace{-.15in}% [[
adam@282 82 = 1
adam@282 83 : nat
adam@282 84
adam@282 85 ]]
adam@282 86
adam@294 87 One aspect in particular of the definition of [pred_strong1] may be surprising. We took advantage of [Definition]'s syntactic sugar for defining function arguments in the case of [n], but we bound the proofs later with explicit [fun] expressions. Let us see what happens if we write this function in the way that at first seems most natural.
adamc@70 88
adamc@212 89 [[
adamc@70 90 Definition pred_strong1' (n : nat) (pf : n > 0) : nat :=
adamc@70 91 match n with
adamc@70 92 | O => match zgtz pf with end
adamc@70 93 | S n' => n'
adamc@70 94 end.
adam@335 95 ]]
adamc@70 96
adam@335 97 <<
adamc@70 98 Error: In environment
adamc@70 99 n : nat
adamc@70 100 pf : n > 0
adamc@70 101 The term "pf" has type "n > 0" while it is expected to have type
adamc@70 102 "0 > 0"
adam@335 103 >>
adamc@70 104
adamc@212 105 The term [zgtz pf] fails to type-check. Somehow the type checker has failed to take into account information that follows from which [match] branch that term appears in. The problem is that, by default, [match] does not let us use such implied information. To get refined typing, we must always rely on [match] annotations, either written explicitly or inferred.
adamc@70 106
adamc@70 107 In this case, we must use a [return] annotation to declare the relationship between the %\textit{%#<i>#value#</i>#%}% of the [match] discriminee and the %\textit{%#<i>#type#</i>#%}% of the result. There is no annotation that lets us declare a relationship between the discriminee and the type of a variable that is already in scope; hence, we delay the binding of [pf], so that we can use the [return] annotation to express the needed relationship.
adamc@70 108
adam@335 109 We are lucky that Coq's heuristics infer the [return] clause (specifically, [return n > 0 -> nat]) for us in this case. *)
adam@335 110
adam@335 111 Definition pred_strong1' (n : nat) : n > 0 -> nat :=
adam@335 112 match n return n > 0 -> nat with
adam@335 113 | O => fun pf : 0 > 0 => match zgtz pf with end
adam@335 114 | S n' => fun _ => n'
adam@335 115 end.
adam@335 116
adam@335 117 (** By making explicit the functional relationship between value [n] and the result type of the [match], we guide Coq toward proper type checking. The clause for this example follows by simple copying of the original annotation on the definition. In general, however, the [match] annotation inference problem is undecidable. The known undecidable problem of %\index{higher-order unification}\textit{%#<i>#higher-order unification#</i>#%}~\cite{HOU}% reduces to the [match] type inference problem. Over time, Coq is enhanced with more and more heuristics to get around this problem, but there must always exist [match]es whose types Coq cannot infer without annotations.
adamc@70 118
adamc@70 119 Let us now take a look at the OCaml code Coq generates for [pred_strong1]. *)
adamc@70 120
adamc@70 121 Extraction pred_strong1.
adamc@70 122
adamc@70 123 (** %\begin{verbatim}
adamc@70 124 (** val pred_strong1 : nat -> nat **)
adamc@70 125
adamc@70 126 let pred_strong1 = function
adamc@70 127 | O -> assert false (* absurd case *)
adamc@70 128 | S n' -> n'
adamc@70 129 \end{verbatim}%
adamc@70 130
adamc@70 131 #<pre>
adamc@70 132 (** val pred_strong1 : nat -> nat **)
adamc@70 133
adamc@70 134 let pred_strong1 = function
adamc@70 135 | O -> assert false (* absurd case *)
adamc@70 136 | S n' -> n'
adamc@70 137 </pre># *)
adamc@70 138
adamc@70 139 (** The proof argument has disappeared! We get exactly the OCaml code we would have written manually. This is our first demonstration of the main technically interesting feature of Coq program extraction: program components of type [Prop] are erased systematically.
adamc@70 140
adam@335 141 We can reimplement our dependently typed [pred] based on %\index{subset types}\textit{%#<i>#subset types#</i>#%}%, defined in the standard library with the type family %\index{Gallina terms!sig}%[sig]. *)
adamc@70 142
adamc@70 143 Print sig.
adamc@212 144 (** %\vspace{-.15in}% [[
adamc@70 145 Inductive sig (A : Type) (P : A -> Prop) : Type :=
adamc@70 146 exist : forall x : A, P x -> sig P
adamc@212 147
adamc@70 148 ]]
adamc@70 149
adam@335 150 The family [sig] is a Curry-Howard twin of [ex], except that [sig] is in [Type], while [ex] is in [Prop]. That means that [sig] values can survive extraction, while [ex] proofs will always be erased. The actual details of extraction of [sig]s are more subtle, as we will see shortly.
adamc@70 151
adamc@70 152 We rewrite [pred_strong1], using some syntactic sugar for subset types. *)
adamc@70 153
adamc@70 154 Locate "{ _ : _ | _ }".
adamc@212 155 (** %\vspace{-.15in}% [[
adam@335 156 Notation
adamc@70 157 "{ x : A | P }" := sig (fun x : A => P)
adam@302 158 ]]
adam@302 159 *)
adamc@70 160
adamc@70 161 Definition pred_strong2 (s : {n : nat | n > 0}) : nat :=
adamc@70 162 match s with
adamc@70 163 | exist O pf => match zgtz pf with end
adamc@70 164 | exist (S n') _ => n'
adamc@70 165 end.
adamc@70 166
adam@335 167 (** To build a value of a subset type, we use the [exist] constructor, and the details of how to do that follow from the output of our earlier [Print sig] command (where we elided the extra information that parameter [A] is implicit). *)
adam@282 168
adam@282 169 Eval compute in pred_strong2 (exist _ 2 two_gt0).
adam@282 170 (** %\vspace{-.15in}% [[
adam@282 171 = 1
adam@282 172 : nat
adam@302 173 ]]
adam@302 174 *)
adam@282 175
adamc@70 176 Extraction pred_strong2.
adamc@70 177
adamc@70 178 (** %\begin{verbatim}
adamc@70 179 (** val pred_strong2 : nat -> nat **)
adamc@70 180
adamc@70 181 let pred_strong2 = function
adamc@70 182 | O -> assert false (* absurd case *)
adamc@70 183 | S n' -> n'
adamc@70 184 \end{verbatim}%
adamc@70 185
adamc@70 186 #<pre>
adamc@70 187 (** val pred_strong2 : nat -> nat **)
adamc@70 188
adamc@70 189 let pred_strong2 = function
adamc@70 190 | O -> assert false (* absurd case *)
adamc@70 191 | S n' -> n'
adamc@70 192 </pre>#
adamc@70 193
adamc@70 194 We arrive at the same OCaml code as was extracted from [pred_strong1], which may seem surprising at first. The reason is that a value of [sig] is a pair of two pieces, a value and a proof about it. Extraction erases the proof, which reduces the constructor [exist] of [sig] to taking just a single argument. An optimization eliminates uses of datatypes with single constructors taking single arguments, and we arrive back where we started.
adamc@70 195
adamc@70 196 We can continue on in the process of refining [pred]'s type. Let us change its result type to capture that the output is really the predecessor of the input. *)
adamc@70 197
adamc@70 198 Definition pred_strong3 (s : {n : nat | n > 0}) : {m : nat | proj1_sig s = S m} :=
adamc@70 199 match s return {m : nat | proj1_sig s = S m} with
adamc@70 200 | exist 0 pf => match zgtz pf with end
adamc@212 201 | exist (S n') pf => exist _ n' (refl_equal _)
adamc@70 202 end.
adamc@70 203
adam@282 204 Eval compute in pred_strong3 (exist _ 2 two_gt0).
adam@282 205 (** %\vspace{-.15in}% [[
adam@282 206 = exist (fun m : nat => 2 = S m) 1 (refl_equal 2)
adam@282 207 : {m : nat | proj1_sig (exist (lt 0) 2 two_gt0) = S m}
adam@335 208 ]]
adam@302 209 *)
adam@282 210
adam@335 211 (** The function %\index{Gallina terms!proj1\_sig}%[proj1_sig] extracts the base value from a subset type. It turns out that we need to include an explicit [return] clause here, since Coq's heuristics are not smart enough to propagate the result type that we wrote earlier.
adamc@70 212
adamc@70 213 By now, the reader is probably ready to believe that the new [pred_strong] leads to the same OCaml code as we have seen several times so far, and Coq does not disappoint. *)
adamc@70 214
adamc@70 215 Extraction pred_strong3.
adamc@70 216
adamc@70 217 (** %\begin{verbatim}
adamc@70 218 (** val pred_strong3 : nat -> nat **)
adamc@70 219
adamc@70 220 let pred_strong3 = function
adamc@70 221 | O -> assert false (* absurd case *)
adamc@70 222 | S n' -> n'
adamc@70 223 \end{verbatim}%
adamc@70 224
adamc@70 225 #<pre>
adamc@70 226 (** val pred_strong3 : nat -> nat **)
adamc@70 227
adamc@70 228 let pred_strong3 = function
adamc@70 229 | O -> assert false (* absurd case *)
adamc@70 230 | S n' -> n'
adamc@70 231 </pre>#
adamc@70 232
adam@335 233 We have managed to reach a type that is, in a formal sense, the most expressive possible for [pred]. Any other implementation of the same type must have the same input-output behavior. However, there is still room for improvement in making this kind of code easier to write. Here is a version that takes advantage of tactic-based theorem proving. We switch back to passing a separate proof argument instead of using a subset type for the function's input, because this leads to cleaner code. (Recall that [False_rec] is the [Set]-level induction principle for [False], which can be used to produce a value in any [Set] given a proof of [False].) *)
adamc@70 234
adam@297 235 Definition pred_strong4 : forall n : nat, n > 0 -> {m : nat | n = S m}.
adamc@70 236 refine (fun n =>
adamc@212 237 match n with
adamc@70 238 | O => fun _ => False_rec _ _
adamc@70 239 | S n' => fun _ => exist _ n' _
adamc@70 240 end).
adamc@212 241
adamc@77 242 (* begin thide *)
adam@335 243 (** We build [pred_strong4] using tactic-based proving, beginning with a [Definition] command that ends in a period before a definition is given. Such a command enters the interactive proving mode, with the type given for the new identifier as our proof goal. It may seem strange to change perspective so implicitly between programming and proving, but recall that programs and proofs are two sides of the same coin in Coq, thanks to the Curry-Howard correspondence.
adamc@70 244
adam@335 245 We do most of the work with the %\index{tactics!refine}%[refine] tactic, to which we pass a partial %``%#"#proof#"#%''% of the type we are trying to prove. There may be some pieces left to fill in, indicated by underscores. Any underscore that Coq cannot reconstruct with type inference is added as a proof subgoal. In this case, we have two subgoals:
adam@335 246
adam@335 247 %\vspace{.1in} \noindent 2 \coqdockw{subgoals}\vspace{-.1in}%#<tt>2 subgoals</tt>#
adam@335 248 [[
adamc@70 249
adamc@70 250 n : nat
adamc@70 251 _ : 0 > 0
adamc@70 252 ============================
adamc@70 253 False
adam@335 254 ]]
adam@335 255 %\noindent \coqdockw{subgoal} 2 \coqdockw{is}:%#<tt>subgoal 2 is</tt>#
adam@335 256 [[
adamc@70 257 S n' = S n'
adamc@70 258 ]]
adamc@70 259
adamc@70 260 We can see that the first subgoal comes from the second underscore passed to [False_rec], and the second subgoal comes from the second underscore passed to [exist]. In the first case, we see that, though we bound the proof variable with an underscore, it is still available in our proof context. It is hard to refer to underscore-named variables in manual proofs, but automation makes short work of them. Both subgoals are easy to discharge that way, so let us back up and ask to prove all subgoals automatically. *)
adamc@70 261
adamc@70 262 Undo.
adamc@70 263 refine (fun n =>
adamc@212 264 match n with
adamc@70 265 | O => fun _ => False_rec _ _
adamc@70 266 | S n' => fun _ => exist _ n' _
adamc@70 267 end); crush.
adamc@77 268 (* end thide *)
adamc@70 269 Defined.
adamc@70 270
adam@335 271 (** We end the %``%#"#proof#"#%''% with %\index{Vernacular commands!Defined}%[Defined] instead of [Qed], so that the definition we constructed remains visible. This contrasts to the case of ending a proof with [Qed], where the details of the proof are hidden afterward. (More formally, [Defined] marks an identifier as %\index{transparent}\emph{%#<i>#transparent#</i>#%}%, allowing it to be unfolded; while [Qed] marks an identifier as %\index{opaque}\emph{%#<i>#opaque#</i>#%}%, preventing unfolding.) Let us see what our proof script constructed. *)
adamc@70 272
adamc@70 273 Print pred_strong4.
adamc@212 274 (** %\vspace{-.15in}% [[
adamc@70 275 pred_strong4 =
adamc@70 276 fun n : nat =>
adamc@70 277 match n as n0 return (n0 > 0 -> {m : nat | n0 = S m}) with
adamc@70 278 | 0 =>
adamc@70 279 fun _ : 0 > 0 =>
adamc@70 280 False_rec {m : nat | 0 = S m}
adamc@70 281 (Bool.diff_false_true
adamc@70 282 (Bool.absurd_eq_true false
adamc@70 283 (Bool.diff_false_true
adamc@70 284 (Bool.absurd_eq_true false (pred_strong4_subproof n _)))))
adamc@70 285 | S n' =>
adamc@70 286 fun _ : S n' > 0 =>
adamc@70 287 exist (fun m : nat => S n' = S m) n' (refl_equal (S n'))
adamc@70 288 end
adamc@70 289 : forall n : nat, n > 0 -> {m : nat | n = S m}
adamc@212 290
adamc@70 291 ]]
adamc@70 292
adam@282 293 We see the code we entered, with some proofs filled in. The first proof obligation, the second argument to [False_rec], is filled in with a nasty-looking proof term that we can be glad we did not enter by hand. The second proof obligation is a simple reflexivity proof. *)
adamc@70 294
adam@282 295 Eval compute in pred_strong4 two_gt0.
adam@282 296 (** %\vspace{-.15in}% [[
adam@282 297 = exist (fun m : nat => 2 = S m) 1 (refl_equal 2)
adam@282 298 : {m : nat | 2 = S m}
adam@282 299 ]]
adam@282 300
adam@335 301 A tactic modifier called %\index{tactics!abstract}%[abstract] can be helpful for producing shorter terms, by automatically abstracting subgoals into named lemmas. *)
adam@335 302
adam@335 303 (* begin thide *)
adam@335 304 Definition pred_strong4' : forall n : nat, n > 0 -> {m : nat | n = S m}.
adam@335 305 refine (fun n =>
adam@335 306 match n with
adam@335 307 | O => fun _ => False_rec _ _
adam@335 308 | S n' => fun _ => exist _ n' _
adam@335 309 end); abstract crush.
adam@335 310 Defined.
adam@335 311
adam@335 312 Print pred_strong4'.
adam@335 313 (* end thide *)
adam@335 314
adam@335 315 (** %\vspace{-.15in}% [[
adam@335 316 pred_strong4' =
adam@335 317 fun n : nat =>
adam@335 318 match n as n0 return (n0 > 0 -> {m : nat | n0 = S m}) with
adam@335 319 | 0 =>
adam@335 320 fun _H : 0 > 0 =>
adam@335 321 False_rec {m : nat | 0 = S m} (pred_strong4'_subproof n _H)
adam@335 322 | S n' =>
adam@335 323 fun _H : S n' > 0 =>
adam@335 324 exist (fun m : nat => S n' = S m) n' (pred_strong4'_subproof0 n _H)
adam@335 325 end
adam@335 326 : forall n : nat, n > 0 -> {m : nat | n = S m}
adam@335 327 ]]
adam@335 328
adam@338 329 We are almost done with the ideal implementation of dependent predecessor. We can use Coq's syntax extension facility to arrive at code with almost no complexity beyond a Haskell or ML program with a complete specification in a comment. In this book, we will not dwell on the details of syntax extensions; the Coq manual gives a straightforward introduction to them. *)
adamc@70 330
adamc@70 331 Notation "!" := (False_rec _ _).
adamc@70 332 Notation "[ e ]" := (exist _ e _).
adamc@70 333
adam@297 334 Definition pred_strong5 : forall n : nat, n > 0 -> {m : nat | n = S m}.
adamc@70 335 refine (fun n =>
adamc@212 336 match n with
adamc@70 337 | O => fun _ => !
adamc@70 338 | S n' => fun _ => [n']
adamc@70 339 end); crush.
adamc@70 340 Defined.
adamc@71 341
adam@282 342 (** By default, notations are also used in pretty-printing terms, including results of evaluation. *)
adam@282 343
adam@282 344 Eval compute in pred_strong5 two_gt0.
adam@282 345 (** %\vspace{-.15in}% [[
adam@282 346 = [1]
adam@282 347 : {m : nat | 2 = S m}
adam@282 348 ]]
adam@282 349
adam@335 350 One other alternative is worth demonstrating. Recent Coq versions include a facility called %\index{Program}%[Program] that streamlines this style of definition. Here is a complete implementation using [Program].%\index{Vernacular commands!Obligation Tactic}\index{Vernacular commands!Program Definition}% *)
adamc@212 351
adamc@212 352 Obligation Tactic := crush.
adamc@212 353
adamc@212 354 Program Definition pred_strong6 (n : nat) (_ : n > 0) : {m : nat | n = S m} :=
adamc@212 355 match n with
adamc@212 356 | O => _
adamc@212 357 | S n' => n'
adamc@212 358 end.
adamc@212 359
adam@335 360 (** Printing the resulting definition of [pred_strong6] yields a term very similar to what we built with [refine]. [Program] can save time in writing programs that use subset types. Nonetheless, [refine] is often just as effective, and [refine] gives you more control over the form the final term takes, which can be useful when you want to prove additional theorems about your definition. [Program] will sometimes insert type casts that can complicate theorem proving. *)
adamc@212 361
adam@282 362 Eval compute in pred_strong6 two_gt0.
adam@282 363 (** %\vspace{-.15in}% [[
adam@282 364 = [1]
adam@282 365 : {m : nat | 2 = S m}
adam@302 366 ]]
adam@335 367
adam@335 368 In this case, we see that the new definition yields the same computational behavior as before. *)
adam@282 369
adamc@71 370
adamc@71 371 (** * Decidable Proposition Types *)
adamc@71 372
adam@335 373 (** There is another type in the standard library which captures the idea of program values that indicate which of two propositions is true.%\index{Gallina terms!sumbool}% *)
adamc@71 374
adamc@71 375 Print sumbool.
adamc@212 376 (** %\vspace{-.15in}% [[
adamc@71 377 Inductive sumbool (A : Prop) (B : Prop) : Set :=
adamc@71 378 left : A -> {A} + {B} | right : B -> {A} + {B}
adamc@212 379 ]]
adamc@71 380
adamc@212 381 We can define some notations to make working with [sumbool] more convenient. *)
adamc@71 382
adamc@71 383 Notation "'Yes'" := (left _ _).
adamc@71 384 Notation "'No'" := (right _ _).
adamc@71 385 Notation "'Reduce' x" := (if x then Yes else No) (at level 50).
adamc@71 386
adamc@71 387 (** The [Reduce] notation is notable because it demonstrates how [if] is overloaded in Coq. The [if] form actually works when the test expression has any two-constructor inductive type. Moreover, in the [then] and [else] branches, the appropriate constructor arguments are bound. This is important when working with [sumbool]s, when we want to have the proof stored in the test expression available when proving the proof obligations generated in the appropriate branch.
adamc@71 388
adamc@71 389 Now we can write [eq_nat_dec], which compares two natural numbers, returning either a proof of their equality or a proof of their inequality. *)
adamc@71 390
adam@297 391 Definition eq_nat_dec : forall n m : nat, {n = m} + {n <> m}.
adamc@212 392 refine (fix f (n m : nat) : {n = m} + {n <> m} :=
adamc@212 393 match n, m with
adamc@71 394 | O, O => Yes
adamc@71 395 | S n', S m' => Reduce (f n' m')
adamc@71 396 | _, _ => No
adamc@71 397 end); congruence.
adamc@71 398 Defined.
adamc@71 399
adam@282 400 Eval compute in eq_nat_dec 2 2.
adam@282 401 (** %\vspace{-.15in}% [[
adam@282 402 = Yes
adam@282 403 : {2 = 2} + {2 <> 2}
adam@302 404 ]]
adam@302 405 *)
adam@282 406
adam@282 407 Eval compute in eq_nat_dec 2 3.
adam@282 408 (** %\vspace{-.15in}% [[
adam@282 409 = No
adam@341 410 : {2 = 3} + {2 <> 3}
adam@302 411 ]]
adam@302 412 *)
adam@282 413
adam@335 414 (** Note that the [Yes] and [No] notations are hiding proofs establishing the correctness of the outputs.
adam@335 415
adam@335 416 Our definition extracts to reasonable OCaml code. *)
adamc@71 417
adamc@71 418 Extraction eq_nat_dec.
adamc@71 419
adamc@71 420 (** %\begin{verbatim}
adamc@71 421 (** val eq_nat_dec : nat -> nat -> sumbool **)
adamc@71 422
adamc@71 423 let rec eq_nat_dec n m =
adamc@71 424 match n with
adamc@71 425 | O -> (match m with
adamc@71 426 | O -> Left
adamc@71 427 | S n0 -> Right)
adamc@71 428 | S n' -> (match m with
adamc@71 429 | O -> Right
adamc@71 430 | S m' -> eq_nat_dec n' m')
adamc@71 431 \end{verbatim}%
adamc@71 432
adamc@71 433 #<pre>
adamc@71 434 (** val eq_nat_dec : nat -> nat -> sumbool **)
adamc@71 435
adamc@71 436 let rec eq_nat_dec n m =
adamc@71 437 match n with
adamc@71 438 | O -> (match m with
adamc@71 439 | O -> Left
adamc@71 440 | S n0 -> Right)
adamc@71 441 | S n' -> (match m with
adamc@71 442 | O -> Right
adamc@71 443 | S m' -> eq_nat_dec n' m')
adamc@71 444 </pre>#
adamc@71 445
adam@335 446 Proving this kind of decidable equality result is so common that Coq comes with a tactic for automating it.%\index{tactics!decide equality}% *)
adamc@71 447
adamc@71 448 Definition eq_nat_dec' (n m : nat) : {n = m} + {n <> m}.
adamc@71 449 decide equality.
adamc@71 450 Defined.
adamc@71 451
adam@335 452 (** Curious readers can verify that the [decide equality] version extracts to the same OCaml code as our more manual version does. That OCaml code had one undesirable property, which is that it uses %\texttt{%#<tt>#Left#</tt>#%}% and %\texttt{%#<tt>#Right#</tt>#%}% constructors instead of the boolean values built into OCaml. We can fix this, by using Coq's facility for mapping Coq inductive types to OCaml variant types.%\index{Vernacular commands!Extract Inductive}% *)
adamc@71 453
adamc@71 454 Extract Inductive sumbool => "bool" ["true" "false"].
adamc@71 455 Extraction eq_nat_dec'.
adamc@71 456
adamc@71 457 (** %\begin{verbatim}
adamc@71 458 (** val eq_nat_dec' : nat -> nat -> bool **)
adamc@71 459
adamc@71 460 let rec eq_nat_dec' n m0 =
adamc@71 461 match n with
adamc@71 462 | O -> (match m0 with
adamc@71 463 | O -> true
adamc@71 464 | S n0 -> false)
adamc@71 465 | S n0 -> (match m0 with
adamc@71 466 | O -> false
adamc@71 467 | S n1 -> eq_nat_dec' n0 n1)
adamc@71 468 \end{verbatim}%
adamc@71 469
adamc@71 470 #<pre>
adamc@71 471 (** val eq_nat_dec' : nat -> nat -> bool **)
adamc@71 472
adamc@71 473 let rec eq_nat_dec' n m0 =
adamc@71 474 match n with
adamc@71 475 | O -> (match m0 with
adamc@71 476 | O -> true
adamc@71 477 | S n0 -> false)
adamc@71 478 | S n0 -> (match m0 with
adamc@71 479 | O -> false
adamc@71 480 | S n1 -> eq_nat_dec' n0 n1)
adamc@71 481 </pre># *)
adamc@72 482
adamc@72 483 (** %\smallskip%
adamc@72 484
adam@292 485 We can build %``%#"#smart#"#%''% versions of the usual boolean operators and put them to good use in certified programming. For instance, here is a [sumbool] version of boolean %``%#"#or.#"#%''% *)
adamc@72 486
adam@337 487 (* EX: Write a function that decides if an element belongs to a list. *)
adam@337 488
adamc@77 489 (* begin thide *)
adamc@204 490 Notation "x || y" := (if x then Yes else Reduce y).
adamc@72 491
adamc@72 492 (** Let us use it for building a function that decides list membership. We need to assume the existence of an equality decision procedure for the type of list elements. *)
adamc@72 493
adamc@72 494 Section In_dec.
adamc@72 495 Variable A : Set.
adamc@72 496 Variable A_eq_dec : forall x y : A, {x = y} + {x <> y}.
adamc@72 497
adamc@72 498 (** The final function is easy to write using the techniques we have developed so far. *)
adamc@72 499
adamc@212 500 Definition In_dec : forall (x : A) (ls : list A), {In x ls} + {~ In x ls}.
adamc@212 501 refine (fix f (x : A) (ls : list A) : {In x ls} + {~ In x ls} :=
adamc@212 502 match ls with
adamc@72 503 | nil => No
adamc@72 504 | x' :: ls' => A_eq_dec x x' || f x ls'
adamc@72 505 end); crush.
adam@282 506 Defined.
adamc@72 507 End In_dec.
adamc@72 508
adam@282 509 Eval compute in In_dec eq_nat_dec 2 (1 :: 2 :: nil).
adam@282 510 (** %\vspace{-.15in}% [[
adam@282 511 = Yes
adam@282 512 : {In 2 (1 :: 2 :: nil)} + {~ In 2 (1 :: 2 :: nil)}
adam@302 513 ]]
adam@302 514 *)
adam@282 515
adam@282 516 Eval compute in In_dec eq_nat_dec 3 (1 :: 2 :: nil).
adam@282 517 (** %\vspace{-.15in}% [[
adam@282 518 = No
adam@282 519 : {In 3 (1 :: 2 :: nil)} + {~ In 3 (1 :: 2 :: nil)}
adam@302 520 ]]
adam@302 521 *)
adam@282 522
adamc@72 523 (** [In_dec] has a reasonable extraction to OCaml. *)
adamc@72 524
adamc@72 525 Extraction In_dec.
adamc@77 526 (* end thide *)
adamc@72 527
adamc@72 528 (** %\begin{verbatim}
adamc@72 529 (** val in_dec : ('a1 -> 'a1 -> bool) -> 'a1 -> 'a1 list -> bool **)
adamc@72 530
adamc@72 531 let rec in_dec a_eq_dec x = function
adamc@72 532 | Nil -> false
adamc@72 533 | Cons (x', ls') ->
adamc@72 534 (match a_eq_dec x x' with
adamc@72 535 | true -> true
adamc@72 536 | false -> in_dec a_eq_dec x ls')
adamc@72 537 \end{verbatim}%
adamc@72 538
adamc@72 539 #<pre>
adamc@72 540 (** val in_dec : ('a1 -> 'a1 -> bool) -> 'a1 -> 'a1 list -> bool **)
adamc@72 541
adamc@72 542 let rec in_dec a_eq_dec x = function
adamc@72 543 | Nil -> false
adamc@72 544 | Cons (x', ls') ->
adamc@72 545 (match a_eq_dec x x' with
adamc@72 546 | true -> true
adamc@72 547 | false -> in_dec a_eq_dec x ls')
adamc@72 548 </pre># *)
adamc@72 549
adamc@72 550
adamc@72 551 (** * Partial Subset Types *)
adamc@72 552
adam@335 553 (** Our final implementation of dependent predecessor used a very specific argument type to ensure that execution could always complete normally. Sometimes we want to allow execution to fail, and we want a more principled way of signaling failure than returning a default value, as [pred] does for [0]. One approach is to define this type family %\index{Gallina terms!maybe}%[maybe], which is a version of [sig] that allows obligation-free failure. *)
adamc@73 554
adamc@89 555 Inductive maybe (A : Set) (P : A -> Prop) : Set :=
adamc@72 556 | Unknown : maybe P
adamc@72 557 | Found : forall x : A, P x -> maybe P.
adamc@72 558
adamc@73 559 (** We can define some new notations, analogous to those we defined for subset types. *)
adamc@73 560
adamc@72 561 Notation "{{ x | P }}" := (maybe (fun x => P)).
adamc@72 562 Notation "??" := (Unknown _).
adam@335 563 Notation "[| x |]" := (Found _ x _).
adamc@72 564
adamc@73 565 (** Now our next version of [pred] is trivial to write. *)
adamc@73 566
adam@297 567 Definition pred_strong7 : forall n : nat, {{m | n = S m}}.
adamc@73 568 refine (fun n =>
adam@380 569 match n return {{m | n = S m}} with
adamc@73 570 | O => ??
adam@335 571 | S n' => [|n'|]
adamc@73 572 end); trivial.
adamc@73 573 Defined.
adamc@73 574
adam@282 575 Eval compute in pred_strong7 2.
adam@282 576 (** %\vspace{-.15in}% [[
adam@335 577 = [|1|]
adam@282 578 : {{m | 2 = S m}}
adam@335 579 ]]
adam@302 580 *)
adam@282 581
adam@282 582 Eval compute in pred_strong7 0.
adam@282 583 (** %\vspace{-.15in}% [[
adam@282 584 = ??
adam@282 585 : {{m | 0 = S m}}
adam@282 586 ]]
adam@282 587
adam@335 588 Because we used [maybe], one valid implementation of the type we gave [pred_strong7] would return [??] in every case. We can strengthen the type to rule out such vacuous implementations, and the type family %\index{Gallina terms!sumor}%[sumor] from the standard library provides the easiest starting point. For type [A] and proposition [B], [A + {B}] desugars to [sumor A B], whose values are either values of [A] or proofs of [B]. *)
adamc@73 589
adamc@73 590 Print sumor.
adamc@212 591 (** %\vspace{-.15in}% [[
adamc@73 592 Inductive sumor (A : Type) (B : Prop) : Type :=
adamc@73 593 inleft : A -> A + {B} | inright : B -> A + {B}
adam@302 594 ]]
adam@302 595 *)
adamc@73 596
adamc@73 597 (** We add notations for easy use of the [sumor] constructors. The second notation is specialized to [sumor]s whose [A] parameters are instantiated with regular subset types, since this is how we will use [sumor] below. *)
adamc@73 598
adamc@73 599 Notation "!!" := (inright _ _).
adam@335 600 Notation "[|| x ||]" := (inleft _ [x]).
adamc@73 601
adam@335 602 (** Now we are ready to give the final version of possibly failing predecessor. The [sumor]-based type that we use is maximally expressive; any implementation of the type has the same input-output behavior. *)
adamc@73 603
adam@297 604 Definition pred_strong8 : forall n : nat, {m : nat | n = S m} + {n = 0}.
adamc@73 605 refine (fun n =>
adamc@212 606 match n with
adamc@73 607 | O => !!
adam@335 608 | S n' => [||n'||]
adamc@73 609 end); trivial.
adamc@73 610 Defined.
adamc@73 611
adam@282 612 Eval compute in pred_strong8 2.
adam@282 613 (** %\vspace{-.15in}% [[
adam@335 614 = [||1||]
adam@282 615 : {m : nat | 2 = S m} + {2 = 0}
adam@302 616 ]]
adam@302 617 *)
adam@282 618
adam@282 619 Eval compute in pred_strong8 0.
adam@282 620 (** %\vspace{-.15in}% [[
adam@282 621 = !!
adam@282 622 : {m : nat | 0 = S m} + {0 = 0}
adam@302 623 ]]
adam@302 624 *)
adam@282 625
adam@335 626 (** As with our other maximally expressive [pred] function, we arrive at quite simple output values, thanks to notations. *)
adam@335 627
adamc@73 628
adamc@73 629 (** * Monadic Notations *)
adamc@73 630
adam@335 631 (** We can treat [maybe] like a monad%~\cite{Monads}\index{monad}\index{failure monad}%, in the same way that the Haskell [Maybe] type is interpreted as a failure monad. Our [maybe] has the wrong type to be a literal monad, but a %``%#"#bind#"#%''%-like notation will still be helpful. *)
adamc@73 632
adamc@72 633 Notation "x <- e1 ; e2" := (match e1 with
adamc@72 634 | Unknown => ??
adamc@72 635 | Found x _ => e2
adamc@72 636 end)
adamc@72 637 (right associativity, at level 60).
adamc@72 638
adamc@73 639 (** The meaning of [x <- e1; e2] is: First run [e1]. If it fails to find an answer, then announce failure for our derived computation, too. If [e1] %\textit{%#<i>#does#</i>#%}% find an answer, pass that answer on to [e2] to find the final result. The variable [x] can be considered bound in [e2].
adamc@73 640
adam@335 641 This notation is very helpful for composing richly typed procedures. For instance, here is a very simple implementation of a function to take the predecessors of two naturals at once. *)
adamc@73 642
adam@337 643 (* EX: Write a function that tries to compute predecessors of two [nat]s at once. *)
adam@337 644
adam@337 645 (* begin thide *)
adam@297 646 Definition doublePred : forall n1 n2 : nat, {{p | n1 = S (fst p) /\ n2 = S (snd p)}}.
adamc@73 647 refine (fun n1 n2 =>
adamc@212 648 m1 <- pred_strong7 n1;
adamc@212 649 m2 <- pred_strong7 n2;
adam@335 650 [|(m1, m2)|]); tauto.
adamc@73 651 Defined.
adam@337 652 (* end thide *)
adamc@73 653
adam@392 654 (** We can build a [sumor] version of the %``%#"#bind#"#%''% notation and use it to write a similarly straightforward version of this function. %The operator rendered here as $\longleftarrow$ is noted in the source as a less-than character followed by two hyphens.% *)
adamc@73 655
adamc@73 656 (** printing <-- $\longleftarrow$ *)
adamc@73 657
adamc@73 658 Notation "x <-- e1 ; e2" := (match e1 with
adamc@73 659 | inright _ => !!
adamc@73 660 | inleft (exist x _) => e2
adamc@73 661 end)
adamc@73 662 (right associativity, at level 60).
adamc@73 663
adamc@73 664 (** printing * $\times$ *)
adamc@73 665
adam@337 666 (* EX: Write a more expressively typed version of the last exercise. *)
adam@337 667
adam@337 668 (* begin thide *)
adam@297 669 Definition doublePred' : forall n1 n2 : nat,
adam@297 670 {p : nat * nat | n1 = S (fst p) /\ n2 = S (snd p)}
adamc@73 671 + {n1 = 0 \/ n2 = 0}.
adamc@73 672 refine (fun n1 n2 =>
adamc@212 673 m1 <-- pred_strong8 n1;
adamc@212 674 m2 <-- pred_strong8 n2;
adam@335 675 [||(m1, m2)||]); tauto.
adamc@73 676 Defined.
adam@337 677 (* end thide *)
adamc@72 678
adam@392 679 (** This example demonstrates how judicious selection of notations can hide complexities in the rich types of programs. *)
adam@392 680
adamc@72 681
adamc@72 682 (** * A Type-Checking Example *)
adamc@72 683
adam@335 684 (** We can apply these specification types to build a certified type checker for a simple expression language. *)
adamc@75 685
adamc@72 686 Inductive exp : Set :=
adamc@72 687 | Nat : nat -> exp
adamc@72 688 | Plus : exp -> exp -> exp
adamc@72 689 | Bool : bool -> exp
adamc@72 690 | And : exp -> exp -> exp.
adamc@72 691
adamc@75 692 (** We define a simple language of types and its typing rules, in the style introduced in Chapter 4. *)
adamc@75 693
adamc@72 694 Inductive type : Set := TNat | TBool.
adamc@72 695
adamc@72 696 Inductive hasType : exp -> type -> Prop :=
adamc@72 697 | HtNat : forall n,
adamc@72 698 hasType (Nat n) TNat
adamc@72 699 | HtPlus : forall e1 e2,
adamc@72 700 hasType e1 TNat
adamc@72 701 -> hasType e2 TNat
adamc@72 702 -> hasType (Plus e1 e2) TNat
adamc@72 703 | HtBool : forall b,
adamc@72 704 hasType (Bool b) TBool
adamc@72 705 | HtAnd : forall e1 e2,
adamc@72 706 hasType e1 TBool
adamc@72 707 -> hasType e2 TBool
adamc@72 708 -> hasType (And e1 e2) TBool.
adamc@72 709
adamc@75 710 (** It will be helpful to have a function for comparing two types. We build one using [decide equality]. *)
adamc@75 711
adamc@77 712 (* begin thide *)
adamc@75 713 Definition eq_type_dec : forall t1 t2 : type, {t1 = t2} + {t1 <> t2}.
adamc@72 714 decide equality.
adamc@72 715 Defined.
adamc@72 716
adam@292 717 (** Another notation complements the monadic notation for [maybe] that we defined earlier. Sometimes we want to include %``%#"#assertions#"#%''% in our procedures. That is, we want to run a decision procedure and fail if it fails; otherwise, we want to continue, with the proof that it produced made available to us. This infix notation captures that idea, for a procedure that returns an arbitrary two-constructor type. *)
adamc@75 718
adamc@73 719 Notation "e1 ;; e2" := (if e1 then e2 else ??)
adamc@73 720 (right associativity, at level 60).
adamc@73 721
adam@335 722 (** With that notation defined, we can implement a [typeCheck] function, whose code is only more complex than what we would write in ML because it needs to include some extra type annotations. Every [[|e|]] expression adds a [hasType] proof obligation, and [crush] makes short work of them when we add [hasType]'s constructors as hints. *)
adamc@77 723 (* end thide *)
adamc@75 724
adam@297 725 Definition typeCheck : forall e : exp, {{t | hasType e t}}.
adamc@77 726 (* begin thide *)
adamc@72 727 Hint Constructors hasType.
adamc@72 728
adamc@72 729 refine (fix F (e : exp) : {{t | hasType e t}} :=
adam@380 730 match e return {{t | hasType e t}} with
adam@335 731 | Nat _ => [|TNat|]
adamc@72 732 | Plus e1 e2 =>
adamc@72 733 t1 <- F e1;
adamc@72 734 t2 <- F e2;
adamc@72 735 eq_type_dec t1 TNat;;
adamc@72 736 eq_type_dec t2 TNat;;
adam@335 737 [|TNat|]
adam@335 738 | Bool _ => [|TBool|]
adamc@72 739 | And e1 e2 =>
adamc@72 740 t1 <- F e1;
adamc@72 741 t2 <- F e2;
adamc@72 742 eq_type_dec t1 TBool;;
adamc@72 743 eq_type_dec t2 TBool;;
adam@335 744 [|TBool|]
adamc@72 745 end); crush.
adamc@77 746 (* end thide *)
adamc@72 747 Defined.
adamc@72 748
adamc@75 749 (** Despite manipulating proofs, our type checker is easy to run. *)
adamc@75 750
adamc@72 751 Eval simpl in typeCheck (Nat 0).
adamc@212 752 (** %\vspace{-.15in}% [[
adam@335 753 = [|TNat|]
adamc@75 754 : {{t | hasType (Nat 0) t}}
adam@302 755 ]]
adam@302 756 *)
adamc@75 757
adamc@72 758 Eval simpl in typeCheck (Plus (Nat 1) (Nat 2)).
adamc@212 759 (** %\vspace{-.15in}% [[
adam@335 760 = [|TNat|]
adamc@75 761 : {{t | hasType (Plus (Nat 1) (Nat 2)) t}}
adam@302 762 ]]
adam@302 763 *)
adamc@75 764
adamc@72 765 Eval simpl in typeCheck (Plus (Nat 1) (Bool false)).
adamc@212 766 (** %\vspace{-.15in}% [[
adamc@75 767 = ??
adamc@75 768 : {{t | hasType (Plus (Nat 1) (Bool false)) t}}
adam@302 769 ]]
adam@302 770 *)
adamc@75 771
adam@335 772 (** The type checker also extracts to some reasonable OCaml code. *)
adamc@75 773
adamc@75 774 Extraction typeCheck.
adamc@75 775
adamc@75 776 (** %\begin{verbatim}
adamc@75 777 (** val typeCheck : exp -> type0 maybe **)
adamc@75 778
adamc@75 779 let rec typeCheck = function
adamc@75 780 | Nat n -> Found TNat
adamc@75 781 | Plus (e1, e2) ->
adamc@75 782 (match typeCheck e1 with
adamc@75 783 | Unknown -> Unknown
adamc@75 784 | Found t1 ->
adamc@75 785 (match typeCheck e2 with
adamc@75 786 | Unknown -> Unknown
adamc@75 787 | Found t2 ->
adamc@75 788 (match eq_type_dec t1 TNat with
adamc@75 789 | true ->
adamc@75 790 (match eq_type_dec t2 TNat with
adamc@75 791 | true -> Found TNat
adamc@75 792 | false -> Unknown)
adamc@75 793 | false -> Unknown)))
adamc@75 794 | Bool b -> Found TBool
adamc@75 795 | And (e1, e2) ->
adamc@75 796 (match typeCheck e1 with
adamc@75 797 | Unknown -> Unknown
adamc@75 798 | Found t1 ->
adamc@75 799 (match typeCheck e2 with
adamc@75 800 | Unknown -> Unknown
adamc@75 801 | Found t2 ->
adamc@75 802 (match eq_type_dec t1 TBool with
adamc@75 803 | true ->
adamc@75 804 (match eq_type_dec t2 TBool with
adamc@75 805 | true -> Found TBool
adamc@75 806 | false -> Unknown)
adamc@75 807 | false -> Unknown)))
adamc@75 808 \end{verbatim}%
adamc@75 809
adamc@75 810 #<pre>
adamc@75 811 (** val typeCheck : exp -> type0 maybe **)
adamc@75 812
adamc@75 813 let rec typeCheck = function
adamc@75 814 | Nat n -> Found TNat
adamc@75 815 | Plus (e1, e2) ->
adamc@75 816 (match typeCheck e1 with
adamc@75 817 | Unknown -> Unknown
adamc@75 818 | Found t1 ->
adamc@75 819 (match typeCheck e2 with
adamc@75 820 | Unknown -> Unknown
adamc@75 821 | Found t2 ->
adamc@75 822 (match eq_type_dec t1 TNat with
adamc@75 823 | true ->
adamc@75 824 (match eq_type_dec t2 TNat with
adamc@75 825 | true -> Found TNat
adamc@75 826 | false -> Unknown)
adamc@75 827 | false -> Unknown)))
adamc@75 828 | Bool b -> Found TBool
adamc@75 829 | And (e1, e2) ->
adamc@75 830 (match typeCheck e1 with
adamc@75 831 | Unknown -> Unknown
adamc@75 832 | Found t1 ->
adamc@75 833 (match typeCheck e2 with
adamc@75 834 | Unknown -> Unknown
adamc@75 835 | Found t2 ->
adamc@75 836 (match eq_type_dec t1 TBool with
adamc@75 837 | true ->
adamc@75 838 (match eq_type_dec t2 TBool with
adamc@75 839 | true -> Found TBool
adamc@75 840 | false -> Unknown)
adamc@75 841 | false -> Unknown)))
adamc@75 842 </pre># *)
adamc@75 843
adamc@75 844 (** %\smallskip%
adamc@75 845
adam@292 846 We can adapt this implementation to use [sumor], so that we know our type-checker only fails on ill-typed inputs. First, we define an analogue to the %``%#"#assertion#"#%''% notation. *)
adamc@73 847
adamc@77 848 (* begin thide *)
adamc@73 849 Notation "e1 ;;; e2" := (if e1 then e2 else !!)
adamc@73 850 (right associativity, at level 60).
adamc@73 851
adamc@75 852 (** Next, we prove a helpful lemma, which states that a given expression can have at most one type. *)
adamc@75 853
adamc@75 854 Lemma hasType_det : forall e t1,
adamc@73 855 hasType e t1
adam@335 856 -> forall t2, hasType e t2
adamc@73 857 -> t1 = t2.
adamc@73 858 induction 1; inversion 1; crush.
adamc@73 859 Qed.
adamc@73 860
adamc@75 861 (** Now we can define the type-checker. Its type expresses that it only fails on untypable expressions. *)
adamc@75 862
adam@335 863 (** printing <-- $\longleftarrow$ *)
adam@335 864
adamc@77 865 (* end thide *)
adam@297 866 Definition typeCheck' : forall e : exp, {t : type | hasType e t} + {forall t, ~ hasType e t}.
adamc@77 867 (* begin thide *)
adamc@73 868 Hint Constructors hasType.
adamc@75 869 (** We register all of the typing rules as hints. *)
adamc@75 870
adamc@73 871 Hint Resolve hasType_det.
adam@335 872 (** The lemma [hasType_det] will also be useful for proving proof obligations with contradictory contexts. Since its statement includes [forall]-bound variables that do not appear in its conclusion, only [eauto] will apply this hint. *)
adamc@73 873
adamc@75 874 (** Finally, the implementation of [typeCheck] can be transcribed literally, simply switching notations as needed. *)
adamc@212 875
adamc@212 876 refine (fix F (e : exp) : {t : type | hasType e t} + {forall t, ~ hasType e t} :=
adam@380 877 match e return {t : type | hasType e t} + {forall t, ~ hasType e t} with
adam@335 878 | Nat _ => [||TNat||]
adamc@73 879 | Plus e1 e2 =>
adamc@73 880 t1 <-- F e1;
adamc@73 881 t2 <-- F e2;
adamc@73 882 eq_type_dec t1 TNat;;;
adamc@73 883 eq_type_dec t2 TNat;;;
adam@335 884 [||TNat||]
adam@335 885 | Bool _ => [||TBool||]
adamc@73 886 | And e1 e2 =>
adamc@73 887 t1 <-- F e1;
adamc@73 888 t2 <-- F e2;
adamc@73 889 eq_type_dec t1 TBool;;;
adamc@73 890 eq_type_dec t2 TBool;;;
adam@335 891 [||TBool||]
adamc@73 892 end); clear F; crush' tt hasType; eauto.
adamc@75 893
adam@335 894 (** We clear [F], the local name for the recursive function, to avoid strange proofs that refer to recursive calls that we never make. The [crush] variant %\index{tactics!crush'}%[crush'] helps us by performing automatic inversion on instances of the predicates specified in its second argument. Once we throw in [eauto] to apply [hasType_det] for us, we have discharged all the subgoals. *)
adamc@77 895 (* end thide *)
adamc@212 896
adamc@212 897
adamc@73 898 Defined.
adamc@73 899
adamc@75 900 (** The short implementation here hides just how time-saving automation is. Every use of one of the notations adds a proof obligation, giving us 12 in total. Most of these obligations require multiple inversions and either uses of [hasType_det] or applications of [hasType] rules.
adamc@75 901
adam@335 902 Our new function remains easy to test: *)
adamc@75 903
adamc@73 904 Eval simpl in typeCheck' (Nat 0).
adamc@212 905 (** %\vspace{-.15in}% [[
adam@335 906 = [||TNat||]
adamc@75 907 : {t : type | hasType (Nat 0) t} +
adamc@75 908 {(forall t : type, ~ hasType (Nat 0) t)}
adam@302 909 ]]
adam@302 910 *)
adamc@75 911
adamc@73 912 Eval simpl in typeCheck' (Plus (Nat 1) (Nat 2)).
adamc@212 913 (** %\vspace{-.15in}% [[
adam@335 914 = [||TNat||]
adamc@75 915 : {t : type | hasType (Plus (Nat 1) (Nat 2)) t} +
adamc@75 916 {(forall t : type, ~ hasType (Plus (Nat 1) (Nat 2)) t)}
adam@302 917 ]]
adam@302 918 *)
adamc@75 919
adamc@73 920 Eval simpl in typeCheck' (Plus (Nat 1) (Bool false)).
adamc@212 921 (** %\vspace{-.15in}% [[
adamc@75 922 = !!
adamc@75 923 : {t : type | hasType (Plus (Nat 1) (Bool false)) t} +
adamc@75 924 {(forall t : type, ~ hasType (Plus (Nat 1) (Bool false)) t)}
adam@302 925 ]]
adam@335 926
adam@335 927 The results of simplifying calls to [typeCheck'] look deceptively similar to the results for [typeCheck], but now the types of the results provide more information. *)