Mercurial > cpdt > repo

annotate src/Subset.v @ 573:c3d77f2bb92c

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