Mercurial > cpdt > repo

annotate src/Subset.v @ 552:c8d01fb69970

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
RSS update
author Adam Chlipala <adam@chlipala.net>
date Wed, 12 Jul 2017 14:57:20 -0400
parents ed829eaa91b2
children af97676583f3
rev   line source
adam@534 1 (* Copyright (c) 2008-2012, 2015, 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@534 13 Require Import Cpdt.CpdtTactics.
adamc@70 14
adamc@70 15 Set Implicit Arguments.
adam@534 16 Set Asymmetric Patterns.
adamc@70 17 (* end hide *)
adamc@70 18
adam@403 19 (** printing <-- $\longleftarrow$ *)
adam@403 20
adamc@70 21
adamc@74 22 (** %\part{Programming with Dependent Types}
adamc@74 23
adamc@74 24 \chapter{Subset Types and Variations}% *)
adamc@70 25
adam@423 26 (** 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}% _dependent types_ 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 27
adamc@70 28
adamc@70 29 (** * Introducing Subset Types *)
adamc@70 30
adamc@70 31 (** Let us consider several ways of implementing the natural number predecessor function. We start by displaying the definition from the standard library: *)
adamc@70 32
adamc@70 33 Print pred.
adamc@212 34 (** %\vspace{-.15in}% [[
adamc@70 35 pred = fun n : nat => match n with
adamc@70 36 | 0 => 0
adamc@70 37 | S u => u
adamc@70 38 end
adamc@70 39 : nat -> nat
adamc@212 40
adamc@212 41 ]]
adamc@70 42
adam@335 43 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 44
adamc@70 45 Extraction pred.
adamc@70 46
adamc@70 47 (** %\begin{verbatim}
adamc@70 48 (** val pred : nat -> nat **)
adamc@70 49
adamc@70 50 let pred = function
adamc@70 51 | O -> O
adamc@70 52 | S u -> u
adamc@70 53 \end{verbatim}%
adamc@70 54
adamc@70 55 #<pre>
adamc@70 56 (** val pred : nat -> nat **)
adamc@70 57
adamc@70 58 let pred = function
adamc@70 59 | O -> O
adamc@70 60 | S u -> u
adamc@70 61 </pre># *)
adamc@70 62
adamc@70 63 (** 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 64
adamc@70 65 Lemma zgtz : 0 > 0 -> False.
adamc@70 66 crush.
adamc@70 67 Qed.
adamc@70 68
adamc@70 69 Definition pred_strong1 (n : nat) : n > 0 -> nat :=
adamc@212 70 match n with
adamc@70 71 | O => fun pf : 0 > 0 => match zgtz pf with end
adamc@70 72 | S n' => fun _ => n'
adamc@70 73 end.
adamc@70 74
adam@398 75 (** We expand the type of [pred] to include a _proof_ 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 _dependent_ type, because its type depends on the _value_ of the argument [n].
adamc@70 76
adam@398 77 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 _implicit_, since it can be deduced from the type of the second argument, so we need not write [n] in function calls. *)
adam@282 78
adam@282 79 Theorem two_gt0 : 2 > 0.
adam@282 80 crush.
adam@282 81 Qed.
adam@282 82
adam@282 83 Eval compute in pred_strong1 two_gt0.
adam@282 84 (** %\vspace{-.15in}% [[
adam@282 85 = 1
adam@282 86 : nat
adam@282 87 ]]
adam@282 88
adam@442 89 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 90
adam@440 91 %\vspace{-.15in}%[[
adamc@70 92 Definition pred_strong1' (n : nat) (pf : n > 0) : nat :=
adamc@70 93 match n with
adamc@70 94 | O => match zgtz pf with end
adamc@70 95 | S n' => n'
adamc@70 96 end.
adam@335 97 ]]
adamc@70 98
adam@335 99 <<
adamc@70 100 Error: In environment
adamc@70 101 n : nat
adamc@70 102 pf : n > 0
adamc@70 103 The term "pf" has type "n > 0" while it is expected to have type
adamc@70 104 "0 > 0"
adam@335 105 >>
adamc@70 106
adamc@212 107 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 108
adam@398 109 In this case, we must use a [return] annotation to declare the relationship between the _value_ of the [match] discriminee and the _type_ 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 110
adam@471 111 We are lucky that Coq's heuristics infer the [return] clause (specifically, [return n > 0 -> nat]) for us in the definition of [pred_strong1], leading to the following elaborated code: *)
adam@335 112
adam@335 113 Definition pred_strong1' (n : nat) : n > 0 -> nat :=
adam@335 114 match n return n > 0 -> nat with
adam@335 115 | O => fun pf : 0 > 0 => match zgtz pf with end
adam@335 116 | S n' => fun _ => n'
adam@335 117 end.
adam@335 118
adam@403 119 (** 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}% _higher-order unification_ %\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 120
adamc@70 121 Let us now take a look at the OCaml code Coq generates for [pred_strong1]. *)
adamc@70 122
adamc@70 123 Extraction pred_strong1.
adamc@70 124
adamc@70 125 (** %\begin{verbatim}
adamc@70 126 (** val pred_strong1 : nat -> nat **)
adamc@70 127
adamc@70 128 let pred_strong1 = function
adamc@70 129 | O -> assert false (* absurd case *)
adamc@70 130 | S n' -> n'
adamc@70 131 \end{verbatim}%
adamc@70 132
adamc@70 133 #<pre>
adamc@70 134 (** val pred_strong1 : nat -> nat **)
adamc@70 135
adamc@70 136 let pred_strong1 = function
adamc@70 137 | O -> assert false (* absurd case *)
adamc@70 138 | S n' -> n'
adamc@70 139 </pre># *)
adamc@70 140
adam@451 141 (** 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: proofs are erased systematically.
adamc@70 142
adam@471 143 %\medskip%
adam@471 144
adam@403 145 We can reimplement our dependently typed [pred] based on%\index{subset types}% _subset types_, defined in the standard library with the type family %\index{Gallina terms!sig}%[sig]. *)
adamc@70 146
adam@423 147 (* begin hide *)
adam@437 148 (* begin thide *)
adam@437 149 Definition bar := ex.
adam@437 150 (* end thide *)
adam@423 151 (* end hide *)
adam@423 152
adamc@70 153 Print sig.
adamc@212 154 (** %\vspace{-.15in}% [[
adamc@70 155 Inductive sig (A : Type) (P : A -> Prop) : Type :=
adamc@70 156 exist : forall x : A, P x -> sig P
adamc@70 157 ]]
adamc@70 158
adam@442 159 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 160
adamc@70 161 We rewrite [pred_strong1], using some syntactic sugar for subset types. *)
adamc@70 162
adamc@70 163 Locate "{ _ : _ | _ }".
adamc@212 164 (** %\vspace{-.15in}% [[
adam@495 165 Notation
adam@495 166 "{ x : A | P }" := sig (fun x : A => P)
adam@495 167 ]]
adam@302 168 *)
adamc@70 169
adamc@70 170 Definition pred_strong2 (s : {n : nat | n > 0}) : nat :=
adamc@70 171 match s with
adamc@70 172 | exist O pf => match zgtz pf with end
adamc@70 173 | exist (S n') _ => n'
adamc@70 174 end.
adamc@70 175
adam@474 176 (** 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. We need an extra [_] here and not in the definition of [pred_strong2] because _parameters_ of inductive types (like the predicate [P] for [sig]) are not mentioned in pattern matching, but _are_ mentioned in construction of terms (if they are not marked as implicit arguments). *)
adam@282 177
adam@282 178 Eval compute in pred_strong2 (exist _ 2 two_gt0).
adam@282 179 (** %\vspace{-.15in}% [[
adam@282 180 = 1
adam@282 181 : nat
adam@302 182 ]]
adam@302 183 *)
adam@282 184
adamc@70 185 Extraction pred_strong2.
adamc@70 186
adamc@70 187 (** %\begin{verbatim}
adamc@70 188 (** val pred_strong2 : nat -> nat **)
adamc@70 189
adamc@70 190 let pred_strong2 = function
adamc@70 191 | O -> assert false (* absurd case *)
adamc@70 192 | S n' -> n'
adamc@70 193 \end{verbatim}%
adamc@70 194
adamc@70 195 #<pre>
adamc@70 196 (** val pred_strong2 : nat -> nat **)
adamc@70 197
adamc@70 198 let pred_strong2 = function
adamc@70 199 | O -> assert false (* absurd case *)
adamc@70 200 | S n' -> n'
adamc@70 201 </pre>#
adamc@70 202
adamc@70 203 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 204
adamc@70 205 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 206
adamc@70 207 Definition pred_strong3 (s : {n : nat | n > 0}) : {m : nat | proj1_sig s = S m} :=
adamc@70 208 match s return {m : nat | proj1_sig s = S m} with
adamc@70 209 | exist 0 pf => match zgtz pf with end
adam@426 210 | exist (S n') pf => exist _ n' (eq_refl _)
adamc@70 211 end.
adamc@70 212
adam@495 213 (* begin hide *)
adam@495 214 (* begin thide *)
adam@495 215 Definition ugh := lt.
adam@495 216 (* end thide *)
adam@495 217 (* end hide *)
adam@495 218
adam@282 219 Eval compute in pred_strong3 (exist _ 2 two_gt0).
adam@282 220 (** %\vspace{-.15in}% [[
adam@426 221 = exist (fun m : nat => 2 = S m) 1 (eq_refl 2)
adam@282 222 : {m : nat | proj1_sig (exist (lt 0) 2 two_gt0) = S m}
adam@335 223 ]]
adam@302 224 *)
adam@282 225
adam@423 226 (* begin hide *)
adam@437 227 (* begin thide *)
adam@423 228 Definition pred_strong := 0.
adam@437 229 (* end thide *)
adam@423 230 (* end hide *)
adam@423 231
adam@474 232 (** A value in a subset type can be thought of as a%\index{dependent pair}% _dependent pair_ (or%\index{sigma type}% _sigma type_) of a base value and a proof about it. The function %\index{Gallina terms!proj1\_sig}%[proj1_sig] extracts the first component of the pair. 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 233
adamc@70 234 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 235
adamc@70 236 Extraction pred_strong3.
adamc@70 237
adamc@70 238 (** %\begin{verbatim}
adamc@70 239 (** val pred_strong3 : nat -> nat **)
adamc@70 240
adamc@70 241 let pred_strong3 = function
adamc@70 242 | O -> assert false (* absurd case *)
adamc@70 243 | S n' -> n'
adamc@70 244 \end{verbatim}%
adamc@70 245
adamc@70 246 #<pre>
adamc@70 247 (** val pred_strong3 : nat -> nat **)
adamc@70 248
adamc@70 249 let pred_strong3 = function
adamc@70 250 | O -> assert false (* absurd case *)
adamc@70 251 | S n' -> n'
adamc@70 252 </pre>#
adamc@70 253
adam@335 254 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 255
adam@297 256 Definition pred_strong4 : forall n : nat, n > 0 -> {m : nat | n = S m}.
adamc@70 257 refine (fun n =>
adamc@212 258 match n with
adamc@70 259 | O => fun _ => False_rec _ _
adamc@70 260 | S n' => fun _ => exist _ n' _
adamc@70 261 end).
adamc@212 262
adamc@77 263 (* begin thide *)
adam@335 264 (** 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 265
adam@423 266 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 267
adam@335 268 [[
adam@439 269 2 subgoals
adamc@70 270
adamc@70 271 n : nat
adamc@70 272 _ : 0 > 0
adamc@70 273 ============================
adamc@70 274 False
adam@439 275
adam@439 276 subgoal 2 is
adam@439 277
adamc@70 278 S n' = S n'
adamc@70 279 ]]
adamc@70 280
adamc@70 281 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 282
adamc@70 283 Undo.
adamc@70 284 refine (fun n =>
adamc@212 285 match n with
adamc@70 286 | O => fun _ => False_rec _ _
adamc@70 287 | S n' => fun _ => exist _ n' _
adamc@70 288 end); crush.
adamc@77 289 (* end thide *)
adamc@70 290 Defined.
adamc@70 291
adam@423 292 (** 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}% _transparent_, allowing it to be unfolded; while [Qed] marks an identifier as%\index{opaque}% _opaque_, preventing unfolding.) Let us see what our proof script constructed. *)
adamc@70 293
adamc@70 294 Print pred_strong4.
adamc@212 295 (** %\vspace{-.15in}% [[
adamc@70 296 pred_strong4 =
adamc@70 297 fun n : nat =>
adamc@70 298 match n as n0 return (n0 > 0 -> {m : nat | n0 = S m}) with
adamc@70 299 | 0 =>
adamc@70 300 fun _ : 0 > 0 =>
adamc@70 301 False_rec {m : nat | 0 = S m}
adamc@70 302 (Bool.diff_false_true
adamc@70 303 (Bool.absurd_eq_true false
adamc@70 304 (Bool.diff_false_true
adamc@70 305 (Bool.absurd_eq_true false (pred_strong4_subproof n _)))))
adamc@70 306 | S n' =>
adamc@70 307 fun _ : S n' > 0 =>
adam@426 308 exist (fun m : nat => S n' = S m) n' (eq_refl (S n'))
adamc@70 309 end
adamc@70 310 : forall n : nat, n > 0 -> {m : nat | n = S m}
adamc@70 311 ]]
adamc@70 312
adam@442 313 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 314
adam@282 315 Eval compute in pred_strong4 two_gt0.
adam@282 316 (** %\vspace{-.15in}% [[
adam@426 317 = exist (fun m : nat => 2 = S m) 1 (eq_refl 2)
adam@282 318 : {m : nat | 2 = S m}
adam@282 319 ]]
adam@282 320
adam@442 321 A tactic modifier called %\index{tactics!abstract}%[abstract] can be helpful for producing shorter terms, by automatically abstracting subgoals into named lemmas. *)
adam@335 322
adam@335 323 (* begin thide *)
adam@335 324 Definition pred_strong4' : forall n : nat, n > 0 -> {m : nat | n = S m}.
adam@335 325 refine (fun n =>
adam@335 326 match n with
adam@335 327 | O => fun _ => False_rec _ _
adam@335 328 | S n' => fun _ => exist _ n' _
adam@335 329 end); abstract crush.
adam@335 330 Defined.
adam@335 331
adam@335 332 Print pred_strong4'.
adam@335 333 (* end thide *)
adam@335 334
adam@335 335 (** %\vspace{-.15in}% [[
adam@335 336 pred_strong4' =
adam@335 337 fun n : nat =>
adam@335 338 match n as n0 return (n0 > 0 -> {m : nat | n0 = S m}) with
adam@335 339 | 0 =>
adam@335 340 fun _H : 0 > 0 =>
adam@335 341 False_rec {m : nat | 0 = S m} (pred_strong4'_subproof n _H)
adam@335 342 | S n' =>
adam@335 343 fun _H : S n' > 0 =>
adam@335 344 exist (fun m : nat => S n' = S m) n' (pred_strong4'_subproof0 n _H)
adam@335 345 end
adam@335 346 : forall n : nat, n > 0 -> {m : nat | n = S m}
adam@335 347 ]]
adam@335 348
adam@338 349 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 350
adamc@70 351 Notation "!" := (False_rec _ _).
adamc@70 352 Notation "[ e ]" := (exist _ e _).
adamc@70 353
adam@297 354 Definition pred_strong5 : forall n : nat, n > 0 -> {m : nat | n = S m}.
adamc@70 355 refine (fun n =>
adamc@212 356 match n with
adamc@70 357 | O => fun _ => !
adamc@70 358 | S n' => fun _ => [n']
adamc@70 359 end); crush.
adamc@70 360 Defined.
adamc@71 361
adam@282 362 (** By default, notations are also used in pretty-printing terms, including results of evaluation. *)
adam@282 363
adam@282 364 Eval compute in pred_strong5 two_gt0.
adam@282 365 (** %\vspace{-.15in}% [[
adam@282 366 = [1]
adam@282 367 : {m : nat | 2 = S m}
adam@282 368 ]]
adam@282 369
adam@442 370 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 371
adamc@212 372 Obligation Tactic := crush.
adamc@212 373
adamc@212 374 Program Definition pred_strong6 (n : nat) (_ : n > 0) : {m : nat | n = S m} :=
adamc@212 375 match n with
adamc@212 376 | O => _
adamc@212 377 | S n' => n'
adamc@212 378 end.
adamc@212 379
adam@495 380 (** 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 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 381
adam@282 382 Eval compute in pred_strong6 two_gt0.
adam@282 383 (** %\vspace{-.15in}% [[
adam@282 384 = [1]
adam@282 385 : {m : nat | 2 = S m}
adam@302 386 ]]
adam@335 387
adam@442 388 In this case, we see that the new definition yields the same computational behavior as before. *)
adam@282 389
adamc@71 390
adamc@71 391 (** * Decidable Proposition Types *)
adamc@71 392
adam@495 393 (** There is another type in the standard library that captures the idea of program values that indicate which of two propositions is true.%\index{Gallina terms!sumbool}% *)
adamc@71 394
adamc@71 395 Print sumbool.
adamc@212 396 (** %\vspace{-.15in}% [[
adamc@71 397 Inductive sumbool (A : Prop) (B : Prop) : Set :=
adamc@71 398 left : A -> {A} + {B} | right : B -> {A} + {B}
adamc@212 399 ]]
adamc@71 400
adam@471 401 Here, the constructors of [sumbool] have types written in terms of a registered notation for [sumbool], such that the result type of each constructor desugars to [sumbool A B]. We can define some notations of our own to make working with [sumbool] more convenient. *)
adamc@71 402
adamc@71 403 Notation "'Yes'" := (left _ _).
adamc@71 404 Notation "'No'" := (right _ _).
adamc@71 405 Notation "'Reduce' x" := (if x then Yes else No) (at level 50).
adamc@71 406
adam@436 407 (** The %\coqdocnotation{%#<tt>#Reduce#</tt>#%}% 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 408
adamc@71 409 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 410
adam@297 411 Definition eq_nat_dec : forall n m : nat, {n = m} + {n <> m}.
adamc@212 412 refine (fix f (n m : nat) : {n = m} + {n <> m} :=
adamc@212 413 match n, m with
adamc@71 414 | O, O => Yes
adamc@71 415 | S n', S m' => Reduce (f n' m')
adamc@71 416 | _, _ => No
adamc@71 417 end); congruence.
adamc@71 418 Defined.
adamc@71 419
adam@282 420 Eval compute in eq_nat_dec 2 2.
adam@282 421 (** %\vspace{-.15in}% [[
adam@282 422 = Yes
adam@282 423 : {2 = 2} + {2 <> 2}
adam@302 424 ]]
adam@302 425 *)
adam@282 426
adam@282 427 Eval compute in eq_nat_dec 2 3.
adam@282 428 (** %\vspace{-.15in}% [[
adam@282 429 = No
adam@341 430 : {2 = 3} + {2 <> 3}
adam@302 431 ]]
adam@282 432
adam@442 433 Note that the %\coqdocnotation{%#<tt>#Yes#</tt>#%}% and %\coqdocnotation{%#<tt>#No#</tt>#%}% notations are hiding proofs establishing the correctness of the outputs.
adam@335 434
adam@335 435 Our definition extracts to reasonable OCaml code. *)
adamc@71 436
adamc@71 437 Extraction eq_nat_dec.
adamc@71 438
adamc@71 439 (** %\begin{verbatim}
adamc@71 440 (** val eq_nat_dec : nat -> nat -> sumbool **)
adamc@71 441
adamc@71 442 let rec eq_nat_dec n m =
adamc@71 443 match n with
adamc@71 444 | O -> (match m with
adamc@71 445 | O -> Left
adamc@71 446 | S n0 -> Right)
adamc@71 447 | S n' -> (match m with
adamc@71 448 | O -> Right
adamc@71 449 | S m' -> eq_nat_dec n' m')
adamc@71 450 \end{verbatim}%
adamc@71 451
adamc@71 452 #<pre>
adamc@71 453 (** val eq_nat_dec : nat -> nat -> sumbool **)
adamc@71 454
adamc@71 455 let rec eq_nat_dec n m =
adamc@71 456 match n with
adamc@71 457 | O -> (match m with
adamc@71 458 | O -> Left
adamc@71 459 | S n0 -> Right)
adamc@71 460 | S n' -> (match m with
adamc@71 461 | O -> Right
adamc@71 462 | S m' -> eq_nat_dec n' m')
adamc@71 463 </pre>#
adamc@71 464
adam@335 465 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 466
adamc@71 467 Definition eq_nat_dec' (n m : nat) : {n = m} + {n <> m}.
adamc@71 468 decide equality.
adamc@71 469 Defined.
adamc@71 470
adam@448 471 (** 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 <<Left>> and <<Right>> 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 472
adamc@71 473 Extract Inductive sumbool => "bool" ["true" "false"].
adamc@71 474 Extraction eq_nat_dec'.
adamc@71 475
adamc@71 476 (** %\begin{verbatim}
adamc@71 477 (** val eq_nat_dec' : nat -> nat -> bool **)
adamc@71 478
adamc@71 479 let rec eq_nat_dec' n m0 =
adamc@71 480 match n with
adamc@71 481 | O -> (match m0 with
adamc@71 482 | O -> true
adamc@71 483 | S n0 -> false)
adamc@71 484 | S n0 -> (match m0 with
adamc@71 485 | O -> false
adamc@71 486 | S n1 -> eq_nat_dec' n0 n1)
adamc@71 487 \end{verbatim}%
adamc@71 488
adamc@71 489 #<pre>
adamc@71 490 (** val eq_nat_dec' : nat -> nat -> bool **)
adamc@71 491
adamc@71 492 let rec eq_nat_dec' n m0 =
adamc@71 493 match n with
adamc@71 494 | O -> (match m0 with
adamc@71 495 | O -> true
adamc@71 496 | S n0 -> false)
adamc@71 497 | S n0 -> (match m0 with
adamc@71 498 | O -> false
adamc@71 499 | S n1 -> eq_nat_dec' n0 n1)
adamc@71 500 </pre># *)
adamc@72 501
adamc@72 502 (** %\smallskip%
adamc@72 503
adam@448 504 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 505
adam@337 506 (* EX: Write a function that decides if an element belongs to a list. *)
adam@337 507
adamc@77 508 (* begin thide *)
adamc@204 509 Notation "x || y" := (if x then Yes else Reduce y).
adamc@72 510
adamc@72 511 (** 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 512
adamc@72 513 Section In_dec.
adamc@72 514 Variable A : Set.
adamc@72 515 Variable A_eq_dec : forall x y : A, {x = y} + {x <> y}.
adamc@72 516
adamc@72 517 (** The final function is easy to write using the techniques we have developed so far. *)
adamc@72 518
adamc@212 519 Definition In_dec : forall (x : A) (ls : list A), {In x ls} + {~ In x ls}.
adamc@212 520 refine (fix f (x : A) (ls : list A) : {In x ls} + {~ In x ls} :=
adamc@212 521 match ls with
adamc@72 522 | nil => No
adamc@72 523 | x' :: ls' => A_eq_dec x x' || f x ls'
adamc@72 524 end); crush.
adam@282 525 Defined.
adamc@72 526 End In_dec.
adamc@72 527
adam@282 528 Eval compute in In_dec eq_nat_dec 2 (1 :: 2 :: nil).
adam@282 529 (** %\vspace{-.15in}% [[
adam@282 530 = Yes
adam@469 531 : {In 2 (1 :: 2 :: nil)} + { ~ In 2 (1 :: 2 :: nil)}
adam@302 532 ]]
adam@302 533 *)
adam@282 534
adam@282 535 Eval compute in In_dec eq_nat_dec 3 (1 :: 2 :: nil).
adam@282 536 (** %\vspace{-.15in}% [[
adam@282 537 = No
adam@469 538 : {In 3 (1 :: 2 :: nil)} + { ~ In 3 (1 :: 2 :: nil)}
adam@302 539 ]]
adam@282 540
adam@469 541 The [In_dec] function has a reasonable extraction to OCaml. *)
adamc@72 542
adamc@72 543 Extraction In_dec.
adamc@77 544 (* end thide *)
adamc@72 545
adamc@72 546 (** %\begin{verbatim}
adamc@72 547 (** val in_dec : ('a1 -> 'a1 -> bool) -> 'a1 -> 'a1 list -> bool **)
adamc@72 548
adamc@72 549 let rec in_dec a_eq_dec x = function
adamc@72 550 | Nil -> false
adamc@72 551 | Cons (x', ls') ->
adamc@72 552 (match a_eq_dec x x' with
adamc@72 553 | true -> true
adamc@72 554 | false -> in_dec a_eq_dec x ls')
adamc@72 555 \end{verbatim}%
adamc@72 556
adamc@72 557 #<pre>
adamc@72 558 (** val in_dec : ('a1 -> 'a1 -> bool) -> 'a1 -> 'a1 list -> bool **)
adamc@72 559
adamc@72 560 let rec in_dec a_eq_dec x = function
adamc@72 561 | Nil -> false
adamc@72 562 | Cons (x', ls') ->
adamc@72 563 (match a_eq_dec x x' with
adamc@72 564 | true -> true
adamc@72 565 | false -> in_dec a_eq_dec x ls')
adam@403 566 </pre>#
adam@403 567
adam@403 568 This is more or the less code for the corresponding function from the OCaml standard library. *)
adamc@72 569
adamc@72 570
adamc@72 571 (** * Partial Subset Types *)
adamc@72 572
adam@335 573 (** 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 574
adamc@89 575 Inductive maybe (A : Set) (P : A -> Prop) : Set :=
adamc@72 576 | Unknown : maybe P
adamc@72 577 | Found : forall x : A, P x -> maybe P.
adamc@72 578
adamc@73 579 (** We can define some new notations, analogous to those we defined for subset types. *)
adamc@73 580
adamc@72 581 Notation "{{ x | P }}" := (maybe (fun x => P)).
adamc@72 582 Notation "??" := (Unknown _).
adam@335 583 Notation "[| x |]" := (Found _ x _).
adamc@72 584
adamc@73 585 (** Now our next version of [pred] is trivial to write. *)
adamc@73 586
adam@297 587 Definition pred_strong7 : forall n : nat, {{m | n = S m}}.
adamc@73 588 refine (fun n =>
adam@380 589 match n return {{m | n = S m}} with
adamc@73 590 | O => ??
adam@335 591 | S n' => [|n'|]
adamc@73 592 end); trivial.
adamc@73 593 Defined.
adamc@73 594
adam@282 595 Eval compute in pred_strong7 2.
adam@282 596 (** %\vspace{-.15in}% [[
adam@335 597 = [|1|]
adam@282 598 : {{m | 2 = S m}}
adam@335 599 ]]
adam@302 600 *)
adam@282 601
adam@282 602 Eval compute in pred_strong7 0.
adam@282 603 (** %\vspace{-.15in}% [[
adam@282 604 = ??
adam@282 605 : {{m | 0 = S m}}
adam@282 606 ]]
adam@282 607
adam@442 608 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 609
adamc@73 610 Print sumor.
adamc@212 611 (** %\vspace{-.15in}% [[
adamc@73 612 Inductive sumor (A : Type) (B : Prop) : Type :=
adamc@73 613 inleft : A -> A + {B} | inright : B -> A + {B}
adam@302 614 ]]
adamc@73 615
adam@442 616 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 617
adamc@73 618 Notation "!!" := (inright _ _).
adam@335 619 Notation "[|| x ||]" := (inleft _ [x]).
adamc@73 620
adam@335 621 (** 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 622
adam@297 623 Definition pred_strong8 : forall n : nat, {m : nat | n = S m} + {n = 0}.
adamc@73 624 refine (fun n =>
adamc@212 625 match n with
adamc@73 626 | O => !!
adam@335 627 | S n' => [||n'||]
adamc@73 628 end); trivial.
adamc@73 629 Defined.
adamc@73 630
adam@282 631 Eval compute in pred_strong8 2.
adam@282 632 (** %\vspace{-.15in}% [[
adam@335 633 = [||1||]
adam@282 634 : {m : nat | 2 = S m} + {2 = 0}
adam@302 635 ]]
adam@302 636 *)
adam@282 637
adam@282 638 Eval compute in pred_strong8 0.
adam@282 639 (** %\vspace{-.15in}% [[
adam@282 640 = !!
adam@282 641 : {m : nat | 0 = S m} + {0 = 0}
adam@302 642 ]]
adam@302 643 *)
adam@282 644
adam@335 645 (** As with our other maximally expressive [pred] function, we arrive at quite simple output values, thanks to notations. *)
adam@335 646
adamc@73 647
adamc@73 648 (** * Monadic Notations *)
adamc@73 649
adam@471 650 (** 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. %Note that the notation definition uses an ASCII \texttt{<-}, while later code uses (in this rendering) a nicer left arrow $\leftarrow$.% *)
adamc@73 651
adamc@72 652 Notation "x <- e1 ; e2" := (match e1 with
adamc@72 653 | Unknown => ??
adamc@72 654 | Found x _ => e2
adamc@72 655 end)
adamc@72 656 (right associativity, at level 60).
adamc@72 657
adam@398 658 (** 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] _does_ 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 659
adam@335 660 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 661
adam@337 662 (* EX: Write a function that tries to compute predecessors of two [nat]s at once. *)
adam@337 663
adam@337 664 (* begin thide *)
adam@297 665 Definition doublePred : forall n1 n2 : nat, {{p | n1 = S (fst p) /\ n2 = S (snd p)}}.
adamc@73 666 refine (fun n1 n2 =>
adamc@212 667 m1 <- pred_strong7 n1;
adamc@212 668 m2 <- pred_strong7 n2;
adam@335 669 [|(m1, m2)|]); tauto.
adamc@73 670 Defined.
adam@337 671 (* end thide *)
adamc@73 672
adam@471 673 (** We can build a [sumor] version of the "bind" notation and use it to write a similarly straightforward version of this function. %Again, the notation definition exposes the ASCII syntax with an operator \texttt{<-{}-}, while the later code uses a nicer long left arrow $\longleftarrow$.% *)
adamc@73 674
clement@533 675 (** %\def\indash{-}\catcode`-=13\def-{\indash\kern0pt }% *)
clement@533 676
adamc@73 677 Notation "x <-- e1 ; e2" := (match e1 with
adamc@73 678 | inright _ => !!
adamc@73 679 | inleft (exist x _) => e2
adamc@73 680 end)
adamc@73 681 (right associativity, at level 60).
adamc@73 682
clement@533 683 (** %\catcode`-=12% *)(* *)
adamc@73 684 (** printing * $\times$ *)
adamc@73 685
adam@337 686 (* EX: Write a more expressively typed version of the last exercise. *)
adam@337 687
adam@337 688 (* begin thide *)
adam@297 689 Definition doublePred' : forall n1 n2 : nat,
adam@297 690 {p : nat * nat | n1 = S (fst p) /\ n2 = S (snd p)}
adamc@73 691 + {n1 = 0 \/ n2 = 0}.
adamc@73 692 refine (fun n1 n2 =>
adamc@212 693 m1 <-- pred_strong8 n1;
adamc@212 694 m2 <-- pred_strong8 n2;
adam@335 695 [||(m1, m2)||]); tauto.
adamc@73 696 Defined.
adam@337 697 (* end thide *)
adamc@72 698
adam@392 699 (** This example demonstrates how judicious selection of notations can hide complexities in the rich types of programs. *)
adam@392 700
adamc@72 701
adamc@72 702 (** * A Type-Checking Example *)
adamc@72 703
adam@335 704 (** We can apply these specification types to build a certified type checker for a simple expression language. *)
adamc@75 705
adamc@72 706 Inductive exp : Set :=
adamc@72 707 | Nat : nat -> exp
adamc@72 708 | Plus : exp -> exp -> exp
adamc@72 709 | Bool : bool -> exp
adamc@72 710 | And : exp -> exp -> exp.
adamc@72 711
adamc@75 712 (** We define a simple language of types and its typing rules, in the style introduced in Chapter 4. *)
adamc@75 713
adamc@72 714 Inductive type : Set := TNat | TBool.
adamc@72 715
adamc@72 716 Inductive hasType : exp -> type -> Prop :=
adamc@72 717 | HtNat : forall n,
adamc@72 718 hasType (Nat n) TNat
adamc@72 719 | HtPlus : forall e1 e2,
adamc@72 720 hasType e1 TNat
adamc@72 721 -> hasType e2 TNat
adamc@72 722 -> hasType (Plus e1 e2) TNat
adamc@72 723 | HtBool : forall b,
adamc@72 724 hasType (Bool b) TBool
adamc@72 725 | HtAnd : forall e1 e2,
adamc@72 726 hasType e1 TBool
adamc@72 727 -> hasType e2 TBool
adamc@72 728 -> hasType (And e1 e2) TBool.
adamc@72 729
adamc@75 730 (** It will be helpful to have a function for comparing two types. We build one using [decide equality]. *)
adamc@75 731
adamc@77 732 (* begin thide *)
adamc@75 733 Definition eq_type_dec : forall t1 t2 : type, {t1 = t2} + {t1 <> t2}.
adamc@72 734 decide equality.
adamc@72 735 Defined.
adamc@72 736
adam@423 737 (** 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 738
adamc@73 739 Notation "e1 ;; e2" := (if e1 then e2 else ??)
adamc@73 740 (right associativity, at level 60).
adamc@73 741
adam@335 742 (** 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 743 (* end thide *)
adamc@75 744
adam@297 745 Definition typeCheck : forall e : exp, {{t | hasType e t}}.
adamc@77 746 (* begin thide *)
adamc@72 747 Hint Constructors hasType.
adamc@72 748
adamc@72 749 refine (fix F (e : exp) : {{t | hasType e t}} :=
adam@380 750 match e return {{t | hasType e t}} with
adam@335 751 | Nat _ => [|TNat|]
adamc@72 752 | Plus e1 e2 =>
adamc@72 753 t1 <- F e1;
adamc@72 754 t2 <- F e2;
adamc@72 755 eq_type_dec t1 TNat;;
adamc@72 756 eq_type_dec t2 TNat;;
adam@335 757 [|TNat|]
adam@335 758 | Bool _ => [|TBool|]
adamc@72 759 | And e1 e2 =>
adamc@72 760 t1 <- F e1;
adamc@72 761 t2 <- F e2;
adamc@72 762 eq_type_dec t1 TBool;;
adamc@72 763 eq_type_dec t2 TBool;;
adam@335 764 [|TBool|]
adamc@72 765 end); crush.
adamc@77 766 (* end thide *)
adamc@72 767 Defined.
adamc@72 768
adamc@75 769 (** Despite manipulating proofs, our type checker is easy to run. *)
adamc@75 770
adamc@72 771 Eval simpl in typeCheck (Nat 0).
adamc@212 772 (** %\vspace{-.15in}% [[
adam@335 773 = [|TNat|]
adamc@75 774 : {{t | hasType (Nat 0) t}}
adam@302 775 ]]
adam@302 776 *)
adamc@75 777
adamc@72 778 Eval simpl in typeCheck (Plus (Nat 1) (Nat 2)).
adamc@212 779 (** %\vspace{-.15in}% [[
adam@335 780 = [|TNat|]
adamc@75 781 : {{t | hasType (Plus (Nat 1) (Nat 2)) t}}
adam@302 782 ]]
adam@302 783 *)
adamc@75 784
adamc@72 785 Eval simpl in typeCheck (Plus (Nat 1) (Bool false)).
adamc@212 786 (** %\vspace{-.15in}% [[
adamc@75 787 = ??
adamc@75 788 : {{t | hasType (Plus (Nat 1) (Bool false)) t}}
adam@302 789 ]]
adamc@75 790
adam@442 791 The type checker also extracts to some reasonable OCaml code. *)
adamc@75 792
adamc@75 793 Extraction typeCheck.
adamc@75 794
adamc@75 795 (** %\begin{verbatim}
adamc@75 796 (** val typeCheck : exp -> type0 maybe **)
adamc@75 797
adamc@75 798 let rec typeCheck = function
adamc@75 799 | Nat n -> Found TNat
adamc@75 800 | Plus (e1, e2) ->
adamc@75 801 (match typeCheck e1 with
adamc@75 802 | Unknown -> Unknown
adamc@75 803 | Found t1 ->
adamc@75 804 (match typeCheck e2 with
adamc@75 805 | Unknown -> Unknown
adamc@75 806 | Found t2 ->
adamc@75 807 (match eq_type_dec t1 TNat with
adamc@75 808 | true ->
adamc@75 809 (match eq_type_dec t2 TNat with
adamc@75 810 | true -> Found TNat
adamc@75 811 | false -> Unknown)
adamc@75 812 | false -> Unknown)))
adamc@75 813 | Bool b -> Found TBool
adamc@75 814 | And (e1, e2) ->
adamc@75 815 (match typeCheck e1 with
adamc@75 816 | Unknown -> Unknown
adamc@75 817 | Found t1 ->
adamc@75 818 (match typeCheck e2 with
adamc@75 819 | Unknown -> Unknown
adamc@75 820 | Found t2 ->
adamc@75 821 (match eq_type_dec t1 TBool with
adamc@75 822 | true ->
adamc@75 823 (match eq_type_dec t2 TBool with
adamc@75 824 | true -> Found TBool
adamc@75 825 | false -> Unknown)
adamc@75 826 | false -> Unknown)))
adamc@75 827 \end{verbatim}%
adamc@75 828
adamc@75 829 #<pre>
adamc@75 830 (** val typeCheck : exp -> type0 maybe **)
adamc@75 831
adamc@75 832 let rec typeCheck = function
adamc@75 833 | Nat n -> Found TNat
adamc@75 834 | Plus (e1, e2) ->
adamc@75 835 (match typeCheck e1 with
adamc@75 836 | Unknown -> Unknown
adamc@75 837 | Found t1 ->
adamc@75 838 (match typeCheck e2 with
adamc@75 839 | Unknown -> Unknown
adamc@75 840 | Found t2 ->
adamc@75 841 (match eq_type_dec t1 TNat with
adamc@75 842 | true ->
adamc@75 843 (match eq_type_dec t2 TNat with
adamc@75 844 | true -> Found TNat
adamc@75 845 | false -> Unknown)
adamc@75 846 | false -> Unknown)))
adamc@75 847 | Bool b -> Found TBool
adamc@75 848 | And (e1, e2) ->
adamc@75 849 (match typeCheck e1 with
adamc@75 850 | Unknown -> Unknown
adamc@75 851 | Found t1 ->
adamc@75 852 (match typeCheck e2 with
adamc@75 853 | Unknown -> Unknown
adamc@75 854 | Found t2 ->
adamc@75 855 (match eq_type_dec t1 TBool with
adamc@75 856 | true ->
adamc@75 857 (match eq_type_dec t2 TBool with
adamc@75 858 | true -> Found TBool
adamc@75 859 | false -> Unknown)
adamc@75 860 | false -> Unknown)))
adamc@75 861 </pre># *)
adamc@75 862
adamc@75 863 (** %\smallskip%
adamc@75 864
adam@423 865 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 866
adamc@77 867 (* begin thide *)
adamc@73 868 Notation "e1 ;;; e2" := (if e1 then e2 else !!)
adamc@73 869 (right associativity, at level 60).
adamc@73 870
adamc@75 871 (** Next, we prove a helpful lemma, which states that a given expression can have at most one type. *)
adamc@75 872
adamc@75 873 Lemma hasType_det : forall e t1,
adamc@73 874 hasType e t1
adam@335 875 -> forall t2, hasType e t2
adamc@73 876 -> t1 = t2.
adamc@73 877 induction 1; inversion 1; crush.
adamc@73 878 Qed.
adamc@73 879
adamc@75 880 (** Now we can define the type-checker. Its type expresses that it only fails on untypable expressions. *)
adamc@75 881
adamc@77 882 (* end thide *)
adam@297 883 Definition typeCheck' : forall e : exp, {t : type | hasType e t} + {forall t, ~ hasType e t}.
adamc@77 884 (* begin thide *)
adamc@73 885 Hint Constructors hasType.
adam@475 886
adamc@75 887 (** We register all of the typing rules as hints. *)
adamc@75 888
adamc@73 889 Hint Resolve hasType_det.
adam@475 890
adam@335 891 (** 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 892
adamc@75 893 (** Finally, the implementation of [typeCheck] can be transcribed literally, simply switching notations as needed. *)
adamc@212 894
adamc@212 895 refine (fix F (e : exp) : {t : type | hasType e t} + {forall t, ~ hasType e t} :=
adam@380 896 match e return {t : type | hasType e t} + {forall t, ~ hasType e t} with
adam@335 897 | Nat _ => [||TNat||]
adamc@73 898 | Plus e1 e2 =>
adamc@73 899 t1 <-- F e1;
adamc@73 900 t2 <-- F e2;
adamc@73 901 eq_type_dec t1 TNat;;;
adamc@73 902 eq_type_dec t2 TNat;;;
adam@335 903 [||TNat||]
adam@335 904 | Bool _ => [||TBool||]
adamc@73 905 | And e1 e2 =>
adamc@73 906 t1 <-- F e1;
adamc@73 907 t2 <-- F e2;
adamc@73 908 eq_type_dec t1 TBool;;;
adamc@73 909 eq_type_dec t2 TBool;;;
adam@335 910 [||TBool||]
adamc@73 911 end); clear F; crush' tt hasType; eauto.
adamc@75 912
adam@471 913 (** We clear [F], the local name for the recursive function, to avoid strange proofs that refer to recursive calls that we never make. Such a step is usually warranted when defining a recursive function with [refine]. 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 914 (* end thide *)
adamc@212 915
adamc@212 916
adamc@73 917 Defined.
adamc@73 918
adamc@75 919 (** 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 920
adam@335 921 Our new function remains easy to test: *)
adamc@75 922
adamc@73 923 Eval simpl in typeCheck' (Nat 0).
adamc@212 924 (** %\vspace{-.15in}% [[
adam@335 925 = [||TNat||]
adamc@75 926 : {t : type | hasType (Nat 0) t} +
adamc@75 927 {(forall t : type, ~ hasType (Nat 0) t)}
adam@302 928 ]]
adam@302 929 *)
adamc@75 930
adamc@73 931 Eval simpl in typeCheck' (Plus (Nat 1) (Nat 2)).
adamc@212 932 (** %\vspace{-.15in}% [[
adam@335 933 = [||TNat||]
adamc@75 934 : {t : type | hasType (Plus (Nat 1) (Nat 2)) t} +
adamc@75 935 {(forall t : type, ~ hasType (Plus (Nat 1) (Nat 2)) t)}
adam@302 936 ]]
adam@302 937 *)
adamc@75 938
adamc@73 939 Eval simpl in typeCheck' (Plus (Nat 1) (Bool false)).
adamc@212 940 (** %\vspace{-.15in}% [[
adamc@75 941 = !!
adamc@75 942 : {t : type | hasType (Plus (Nat 1) (Bool false)) t} +
adamc@75 943 {(forall t : type, ~ hasType (Plus (Nat 1) (Bool false)) t)}
adam@302 944 ]]
adam@335 945
adam@442 946 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. *)