Mercurial > cpdt > repo

annotate src/Subset.v @ 284:693897f8e0cb

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
PC comments for DataStruct
author Adam Chlipala <adam@chlipala.net>
date Fri, 05 Nov 2010 13:48:39 -0400
parents caa69851c78d
children 2c88fc1dbe33
rev   line source
adam@282 1 (* Copyright (c) 2008-2010, 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
adamc@70 13 Require Import Tactics.
adamc@70 14
adamc@70 15 Set Implicit Arguments.
adamc@70 16 (* end hide *)
adamc@70 17
adamc@70 18
adamc@74 19 (** %\part{Programming with Dependent Types}
adamc@74 20
adamc@74 21 \chapter{Subset Types and Variations}% *)
adamc@70 22
adamc@70 23 (** So far, we have seen many examples of what we might call "classical program verification." We write programs, write their specifications, and then prove that the programs satisfy their specifications. The programs that we have written in Coq have been normal functional programs that we could just as well have written in Haskell or ML. In this chapter, we start investigating uses of %\textit{%#<i>#dependent types#</i>#%}% to integrate programming, specification, and proving into a single phase. *)
adamc@70 24
adamc@70 25
adamc@70 26 (** * Introducing Subset Types *)
adamc@70 27
adamc@70 28 (** Let us consider several ways of implementing the natural number predecessor function. We start by displaying the definition from the standard library: *)
adamc@70 29
adamc@70 30 Print pred.
adamc@212 31 (** %\vspace{-.15in}% [[
adamc@70 32 pred = fun n : nat => match n with
adamc@70 33 | 0 => 0
adamc@70 34 | S u => u
adamc@70 35 end
adamc@70 36 : nat -> nat
adamc@212 37
adamc@212 38 ]]
adamc@70 39
adamc@212 40 We can use a new command, [Extraction], to produce an OCaml version of this function. *)
adamc@70 41
adamc@70 42 Extraction pred.
adamc@70 43
adamc@70 44 (** %\begin{verbatim}
adamc@70 45 (** val pred : nat -> nat **)
adamc@70 46
adamc@70 47 let pred = function
adamc@70 48 | O -> O
adamc@70 49 | S u -> u
adamc@70 50 \end{verbatim}%
adamc@70 51
adamc@70 52 #<pre>
adamc@70 53 (** val pred : nat -> nat **)
adamc@70 54
adamc@70 55 let pred = function
adamc@70 56 | O -> O
adamc@70 57 | S u -> u
adamc@70 58 </pre># *)
adamc@70 59
adamc@70 60 (** Returning 0 as the predecessor of 0 can come across as somewhat of a hack. In some situations, we might like to be sure that we never try to take the predecessor of 0. We can enforce this by giving [pred] a stronger, dependent type. *)
adamc@70 61
adamc@70 62 Lemma zgtz : 0 > 0 -> False.
adamc@70 63 crush.
adamc@70 64 Qed.
adamc@70 65
adamc@70 66 Definition pred_strong1 (n : nat) : n > 0 -> nat :=
adamc@212 67 match n with
adamc@70 68 | O => fun pf : 0 > 0 => match zgtz pf with end
adamc@70 69 | S n' => fun _ => n'
adamc@70 70 end.
adamc@70 71
adamc@70 72 (** We expand the type of [pred] to include a %\textit{%#<i>#proof#</i>#%}% that its argument [n] is greater than 0. When [n] is 0, we use the proof to derive a contradiction, which we can use to build a value of any type via a vacuous pattern match. When [n] is a successor, we have no need for the proof and just return the answer. The proof argument can be said to have a %\textit{%#<i>#dependent#</i>#%}% type, because its type depends on the %\textit{%#<i>#value#</i>#%}% of the argument [n].
adamc@70 73
adam@282 74 Coq's [Eval] command can execute particular invocations of [pred_strong1] just as easily as it can execute more traditional functional programs. Note that Coq has decided that argument [n] of [pred_strong1] can be made %\textit{%#<i>#implicit#</i>#%}%, since it can be deduced from the type of the second argument, so we need not write [n] in function calls. *)
adam@282 75
adam@282 76 Theorem two_gt0 : 2 > 0.
adam@282 77 crush.
adam@282 78 Qed.
adam@282 79
adam@282 80 Eval compute in pred_strong1 two_gt0.
adam@282 81 (** %\vspace{-.15in}% [[
adam@282 82 = 1
adam@282 83 : nat
adam@282 84
adam@282 85 ]]
adam@282 86
adam@282 87 One aspect in particular of the definition of [pred_strong1] may be surprising. We took advantage of [Definition]'s syntactic sugar for defining function arguments in the case of [n], but we bound the proofs later with explicit [fun] expressions. Let us see what happens if we write this function in the way that at first seems most natural.
adamc@70 88
adamc@212 89 [[
adamc@70 90 Definition pred_strong1' (n : nat) (pf : n > 0) : nat :=
adamc@70 91 match n with
adamc@70 92 | O => match zgtz pf with end
adamc@70 93 | S n' => n'
adamc@70 94 end.
adamc@70 95
adamc@70 96 Error: In environment
adamc@70 97 n : nat
adamc@70 98 pf : n > 0
adamc@70 99 The term "pf" has type "n > 0" while it is expected to have type
adamc@70 100 "0 > 0"
adamc@212 101
adamc@70 102 ]]
adamc@70 103
adamc@212 104 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 105
adamc@70 106 In this case, we must use a [return] annotation to declare the relationship between the %\textit{%#<i>#value#</i>#%}% of the [match] discriminee and the %\textit{%#<i>#type#</i>#%}% of the result. There is no annotation that lets us declare a relationship between the discriminee and the type of a variable that is already in scope; hence, we delay the binding of [pf], so that we can use the [return] annotation to express the needed relationship.
adamc@70 107
adamc@212 108 We are lucky that Coq's heuristics infer the [return] clause (specifically, [return n > 0 -> nat]) for us in this case. In general, however, the inference problem is undecidable. The known undecidable problem of %\textit{%#<i>#higher-order unification#</i>#%}% 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 109
adamc@70 110 Let us now take a look at the OCaml code Coq generates for [pred_strong1]. *)
adamc@70 111
adamc@70 112 Extraction pred_strong1.
adamc@70 113
adamc@70 114 (** %\begin{verbatim}
adamc@70 115 (** val pred_strong1 : nat -> nat **)
adamc@70 116
adamc@70 117 let pred_strong1 = function
adamc@70 118 | O -> assert false (* absurd case *)
adamc@70 119 | S n' -> n'
adamc@70 120 \end{verbatim}%
adamc@70 121
adamc@70 122 #<pre>
adamc@70 123 (** val pred_strong1 : nat -> nat **)
adamc@70 124
adamc@70 125 let pred_strong1 = function
adamc@70 126 | O -> assert false (* absurd case *)
adamc@70 127 | S n' -> n'
adamc@70 128 </pre># *)
adamc@70 129
adamc@70 130 (** The proof argument has disappeared! We get exactly the OCaml code we would have written manually. This is our first demonstration of the main technically interesting feature of Coq program extraction: program components of type [Prop] are erased systematically.
adamc@70 131
adamc@70 132 We can reimplement our dependently-typed [pred] based on %\textit{%#<i>#subset types#</i>#%}%, defined in the standard library with the type family [sig]. *)
adamc@70 133
adamc@70 134 Print sig.
adamc@212 135 (** %\vspace{-.15in}% [[
adamc@70 136 Inductive sig (A : Type) (P : A -> Prop) : Type :=
adamc@70 137 exist : forall x : A, P x -> sig P
adamc@70 138 For sig: Argument A is implicit
adamc@70 139 For exist: Argument A is implicit
adamc@212 140
adamc@70 141 ]]
adamc@70 142
adamc@70 143 [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 144
adamc@70 145 We rewrite [pred_strong1], using some syntactic sugar for subset types. *)
adamc@70 146
adamc@70 147 Locate "{ _ : _ | _ }".
adamc@212 148 (** %\vspace{-.15in}% [[
adamc@70 149 Notation Scope
adamc@70 150 "{ x : A | P }" := sig (fun x : A => P)
adamc@70 151 : type_scope
adamc@70 152 (default interpretation)
adamc@70 153 ]] *)
adamc@70 154
adamc@70 155 Definition pred_strong2 (s : {n : nat | n > 0}) : nat :=
adamc@70 156 match s with
adamc@70 157 | exist O pf => match zgtz pf with end
adamc@70 158 | exist (S n') _ => n'
adamc@70 159 end.
adamc@70 160
adam@282 161 (** 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. *)
adam@282 162
adam@282 163 Eval compute in pred_strong2 (exist _ 2 two_gt0).
adam@282 164 (** %\vspace{-.15in}% [[
adam@282 165 = 1
adam@282 166 : nat
adam@282 167
adam@282 168 ]] *)
adam@282 169
adamc@70 170 Extraction pred_strong2.
adamc@70 171
adamc@70 172 (** %\begin{verbatim}
adamc@70 173 (** val pred_strong2 : nat -> nat **)
adamc@70 174
adamc@70 175 let pred_strong2 = function
adamc@70 176 | O -> assert false (* absurd case *)
adamc@70 177 | S n' -> n'
adamc@70 178 \end{verbatim}%
adamc@70 179
adamc@70 180 #<pre>
adamc@70 181 (** val pred_strong2 : nat -> nat **)
adamc@70 182
adamc@70 183 let pred_strong2 = function
adamc@70 184 | O -> assert false (* absurd case *)
adamc@70 185 | S n' -> n'
adamc@70 186 </pre>#
adamc@70 187
adamc@70 188 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 189
adamc@70 190 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 191
adamc@70 192 Definition pred_strong3 (s : {n : nat | n > 0}) : {m : nat | proj1_sig s = S m} :=
adamc@70 193 match s return {m : nat | proj1_sig s = S m} with
adamc@70 194 | exist 0 pf => match zgtz pf with end
adamc@212 195 | exist (S n') pf => exist _ n' (refl_equal _)
adamc@70 196 end.
adamc@70 197
adam@282 198 Eval compute in pred_strong3 (exist _ 2 two_gt0).
adam@282 199 (** %\vspace{-.15in}% [[
adam@282 200 = exist (fun m : nat => 2 = S m) 1 (refl_equal 2)
adam@282 201 : {m : nat | proj1_sig (exist (lt 0) 2 two_gt0) = S m}
adam@282 202
adam@282 203 ]] *)
adam@282 204
adam@282 205 (** The function [proj1_sig] extracts the base value from a subset type. It turns out that we need to include an explicit [return] clause here, since Coq's heuristics are not smart enough to propagate the result type that we wrote earlier.
adamc@70 206
adamc@70 207 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 208
adamc@70 209 Extraction pred_strong3.
adamc@70 210
adamc@70 211 (** %\begin{verbatim}
adamc@70 212 (** val pred_strong3 : nat -> nat **)
adamc@70 213
adamc@70 214 let pred_strong3 = function
adamc@70 215 | O -> assert false (* absurd case *)
adamc@70 216 | S n' -> n'
adamc@70 217 \end{verbatim}%
adamc@70 218
adamc@70 219 #<pre>
adamc@70 220 (** val pred_strong3 : nat -> nat **)
adamc@70 221
adamc@70 222 let pred_strong3 = function
adamc@70 223 | O -> assert false (* absurd case *)
adamc@70 224 | S n' -> n'
adamc@70 225 </pre>#
adamc@70 226
adamc@70 227 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. *)
adamc@70 228
adamc@70 229 Definition pred_strong4 (n : nat) : n > 0 -> {m : nat | n = S m}.
adamc@70 230 refine (fun n =>
adamc@212 231 match n with
adamc@70 232 | O => fun _ => False_rec _ _
adamc@70 233 | S n' => fun _ => exist _ n' _
adamc@70 234 end).
adamc@212 235
adamc@77 236 (* begin thide *)
adamc@70 237 (** 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. We do most of the work with the [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:
adamc@70 238
adamc@70 239 [[
adamc@70 240 2 subgoals
adamc@70 241
adamc@70 242 n : nat
adamc@70 243 _ : 0 > 0
adamc@70 244 ============================
adamc@70 245 False
adamc@70 246
adamc@70 247 subgoal 2 is:
adamc@70 248 S n' = S n'
adamc@212 249
adamc@70 250 ]]
adamc@70 251
adamc@70 252 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 253
adamc@70 254 Undo.
adamc@70 255 refine (fun n =>
adamc@212 256 match n with
adamc@70 257 | O => fun _ => False_rec _ _
adamc@70 258 | S n' => fun _ => exist _ n' _
adamc@70 259 end); crush.
adamc@77 260 (* end thide *)
adamc@70 261 Defined.
adamc@70 262
adamc@76 263 (** We end the "proof" with [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. Let us see what our proof script constructed. *)
adamc@70 264
adamc@70 265 Print pred_strong4.
adamc@212 266 (** %\vspace{-.15in}% [[
adamc@70 267 pred_strong4 =
adamc@70 268 fun n : nat =>
adamc@70 269 match n as n0 return (n0 > 0 -> {m : nat | n0 = S m}) with
adamc@70 270 | 0 =>
adamc@70 271 fun _ : 0 > 0 =>
adamc@70 272 False_rec {m : nat | 0 = S m}
adamc@70 273 (Bool.diff_false_true
adamc@70 274 (Bool.absurd_eq_true false
adamc@70 275 (Bool.diff_false_true
adamc@70 276 (Bool.absurd_eq_true false (pred_strong4_subproof n _)))))
adamc@70 277 | S n' =>
adamc@70 278 fun _ : S n' > 0 =>
adamc@70 279 exist (fun m : nat => S n' = S m) n' (refl_equal (S n'))
adamc@70 280 end
adamc@70 281 : forall n : nat, n > 0 -> {m : nat | n = S m}
adamc@212 282
adamc@70 283 ]]
adamc@70 284
adam@282 285 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 286
adam@282 287 Eval compute in pred_strong4 two_gt0.
adam@282 288 (** %\vspace{-.15in}% [[
adam@282 289 = exist (fun m : nat => 2 = S m) 1 (refl_equal 2)
adam@282 290 : {m : nat | 2 = S m}
adam@282 291
adam@282 292 ]]
adam@282 293
adam@282 294 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. *)
adamc@70 295
adamc@70 296 Notation "!" := (False_rec _ _).
adamc@70 297 Notation "[ e ]" := (exist _ e _).
adamc@70 298
adamc@70 299 Definition pred_strong5 (n : nat) : n > 0 -> {m : nat | n = S m}.
adamc@70 300 refine (fun n =>
adamc@212 301 match n with
adamc@70 302 | O => fun _ => !
adamc@70 303 | S n' => fun _ => [n']
adamc@70 304 end); crush.
adamc@70 305 Defined.
adamc@71 306
adam@282 307 (** By default, notations are also used in pretty-printing terms, including results of evaluation. *)
adam@282 308
adam@282 309 Eval compute in pred_strong5 two_gt0.
adam@282 310 (** %\vspace{-.15in}% [[
adam@282 311 = [1]
adam@282 312 : {m : nat | 2 = S m}
adam@282 313
adam@282 314 ]]
adam@282 315
adam@282 316 One other alternative is worth demonstrating. Recent Coq versions include a facility called [Program] that streamlines this style of definition. Here is a complete implementation using [Program]. *)
adamc@212 317
adamc@212 318 Obligation Tactic := crush.
adamc@212 319
adamc@212 320 Program Definition pred_strong6 (n : nat) (_ : n > 0) : {m : nat | n = S m} :=
adamc@212 321 match n with
adamc@212 322 | O => _
adamc@212 323 | S n' => n'
adamc@212 324 end.
adamc@212 325
adamc@212 326 (** Printing the resulting definition of [pred_strong6] yields a term very similar to what we built with [refine]. [Program] can save time in writing programs that use subset types. Nonetheless, [refine] is often just as effective, and [refine] gives you more control over the form the final term takes, which can be useful when you want to prove additional theorems about your definition. [Program] will sometimes insert type casts that can complicate theorem-proving. *)
adamc@212 327
adam@282 328 Eval compute in pred_strong6 two_gt0.
adam@282 329 (** %\vspace{-.15in}% [[
adam@282 330 = [1]
adam@282 331 : {m : nat | 2 = S m}
adam@282 332
adam@282 333 ]] *)
adam@282 334
adamc@71 335
adamc@71 336 (** * Decidable Proposition Types *)
adamc@71 337
adamc@71 338 (** There is another type in the standard library which captures the idea of program values that indicate which of two propositions is true. *)
adamc@71 339
adamc@71 340 Print sumbool.
adamc@212 341 (** %\vspace{-.15in}% [[
adamc@71 342 Inductive sumbool (A : Prop) (B : Prop) : Set :=
adamc@71 343 left : A -> {A} + {B} | right : B -> {A} + {B}
adamc@71 344 For left: Argument A is implicit
adamc@71 345 For right: Argument B is implicit
adamc@212 346
adamc@212 347 ]]
adamc@71 348
adamc@212 349 We can define some notations to make working with [sumbool] more convenient. *)
adamc@71 350
adamc@71 351 Notation "'Yes'" := (left _ _).
adamc@71 352 Notation "'No'" := (right _ _).
adamc@71 353 Notation "'Reduce' x" := (if x then Yes else No) (at level 50).
adamc@71 354
adamc@71 355 (** The [Reduce] notation is notable because it demonstrates how [if] is overloaded in Coq. The [if] form actually works when the test expression has any two-constructor inductive type. Moreover, in the [then] and [else] branches, the appropriate constructor arguments are bound. This is important when working with [sumbool]s, when we want to have the proof stored in the test expression available when proving the proof obligations generated in the appropriate branch.
adamc@71 356
adamc@71 357 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 358
adamc@71 359 Definition eq_nat_dec (n m : nat) : {n = m} + {n <> m}.
adamc@212 360 refine (fix f (n m : nat) : {n = m} + {n <> m} :=
adamc@212 361 match n, m with
adamc@71 362 | O, O => Yes
adamc@71 363 | S n', S m' => Reduce (f n' m')
adamc@71 364 | _, _ => No
adamc@71 365 end); congruence.
adamc@71 366 Defined.
adamc@71 367
adam@282 368 Eval compute in eq_nat_dec 2 2.
adam@282 369 (** %\vspace{-.15in}% [[
adam@282 370 = Yes
adam@282 371 : {2 = 2} + {2 <> 2}
adam@282 372
adam@282 373 ]] *)
adam@282 374
adam@282 375 Eval compute in eq_nat_dec 2 3.
adam@282 376 (** %\vspace{-.15in}% [[
adam@282 377 = No
adam@282 378 : {2 = 2} + {2 <> 2}
adam@282 379
adam@282 380 ]] *)
adam@282 381
adamc@71 382 (** Our definition extracts to reasonable OCaml code. *)
adamc@71 383
adamc@71 384 Extraction eq_nat_dec.
adamc@71 385
adamc@71 386 (** %\begin{verbatim}
adamc@71 387 (** val eq_nat_dec : nat -> nat -> sumbool **)
adamc@71 388
adamc@71 389 let rec eq_nat_dec n m =
adamc@71 390 match n with
adamc@71 391 | O -> (match m with
adamc@71 392 | O -> Left
adamc@71 393 | S n0 -> Right)
adamc@71 394 | S n' -> (match m with
adamc@71 395 | O -> Right
adamc@71 396 | S m' -> eq_nat_dec n' m')
adamc@71 397 \end{verbatim}%
adamc@71 398
adamc@71 399 #<pre>
adamc@71 400 (** val eq_nat_dec : nat -> nat -> sumbool **)
adamc@71 401
adamc@71 402 let rec eq_nat_dec n m =
adamc@71 403 match n with
adamc@71 404 | O -> (match m with
adamc@71 405 | O -> Left
adamc@71 406 | S n0 -> Right)
adamc@71 407 | S n' -> (match m with
adamc@71 408 | O -> Right
adamc@71 409 | S m' -> eq_nat_dec n' m')
adamc@71 410 </pre>#
adamc@71 411
adamc@71 412 Proving this kind of decidable equality result is so common that Coq comes with a tactic for automating it. *)
adamc@71 413
adamc@71 414 Definition eq_nat_dec' (n m : nat) : {n = m} + {n <> m}.
adamc@71 415 decide equality.
adamc@71 416 Defined.
adamc@71 417
adamc@71 418 (** Curious readers can verify that the [decide equality] version extracts to the same OCaml code as our more manual version does. That OCaml code had one undesirable property, which is that it uses %\texttt{%#<tt>#Left#</tt>#%}% and %\texttt{%#<tt>#Right#</tt>#%}% constructors instead of the boolean values built into OCaml. We can fix this, by using Coq's facility for mapping Coq inductive types to OCaml variant types. *)
adamc@71 419
adamc@71 420 Extract Inductive sumbool => "bool" ["true" "false"].
adamc@71 421 Extraction eq_nat_dec'.
adamc@71 422
adamc@71 423 (** %\begin{verbatim}
adamc@71 424 (** val eq_nat_dec' : nat -> nat -> bool **)
adamc@71 425
adamc@71 426 let rec eq_nat_dec' n m0 =
adamc@71 427 match n with
adamc@71 428 | O -> (match m0 with
adamc@71 429 | O -> true
adamc@71 430 | S n0 -> false)
adamc@71 431 | S n0 -> (match m0 with
adamc@71 432 | O -> false
adamc@71 433 | S n1 -> eq_nat_dec' n0 n1)
adamc@71 434 \end{verbatim}%
adamc@71 435
adamc@71 436 #<pre>
adamc@71 437 (** val eq_nat_dec' : nat -> nat -> bool **)
adamc@71 438
adamc@71 439 let rec eq_nat_dec' n m0 =
adamc@71 440 match n with
adamc@71 441 | O -> (match m0 with
adamc@71 442 | O -> true
adamc@71 443 | S n0 -> false)
adamc@71 444 | S n0 -> (match m0 with
adamc@71 445 | O -> false
adamc@71 446 | S n1 -> eq_nat_dec' n0 n1)
adamc@71 447 </pre># *)
adamc@72 448
adamc@72 449 (** %\smallskip%
adamc@72 450
adamc@72 451 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 452
adamc@77 453 (* begin thide *)
adamc@204 454 Notation "x || y" := (if x then Yes else Reduce y).
adamc@72 455
adamc@72 456 (** 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 457
adamc@72 458 Section In_dec.
adamc@72 459 Variable A : Set.
adamc@72 460 Variable A_eq_dec : forall x y : A, {x = y} + {x <> y}.
adamc@72 461
adamc@72 462 (** The final function is easy to write using the techniques we have developed so far. *)
adamc@72 463
adamc@212 464 Definition In_dec : forall (x : A) (ls : list A), {In x ls} + {~ In x ls}.
adamc@212 465 refine (fix f (x : A) (ls : list A) : {In x ls} + {~ In x ls} :=
adamc@212 466 match ls with
adamc@72 467 | nil => No
adamc@72 468 | x' :: ls' => A_eq_dec x x' || f x ls'
adamc@72 469 end); crush.
adam@282 470 Defined.
adamc@72 471 End In_dec.
adamc@72 472
adam@282 473 Eval compute in In_dec eq_nat_dec 2 (1 :: 2 :: nil).
adam@282 474 (** %\vspace{-.15in}% [[
adam@282 475 = Yes
adam@282 476 : {In 2 (1 :: 2 :: nil)} + {~ In 2 (1 :: 2 :: nil)}
adam@282 477
adam@282 478 ]] *)
adam@282 479
adam@282 480 Eval compute in In_dec eq_nat_dec 3 (1 :: 2 :: nil).
adam@282 481 (** %\vspace{-.15in}% [[
adam@282 482 = No
adam@282 483 : {In 3 (1 :: 2 :: nil)} + {~ In 3 (1 :: 2 :: nil)}
adam@282 484
adam@282 485 ]] *)
adam@282 486
adamc@72 487 (** [In_dec] has a reasonable extraction to OCaml. *)
adamc@72 488
adamc@72 489 Extraction In_dec.
adamc@77 490 (* end thide *)
adamc@72 491
adamc@72 492 (** %\begin{verbatim}
adamc@72 493 (** val in_dec : ('a1 -> 'a1 -> bool) -> 'a1 -> 'a1 list -> bool **)
adamc@72 494
adamc@72 495 let rec in_dec a_eq_dec x = function
adamc@72 496 | Nil -> false
adamc@72 497 | Cons (x', ls') ->
adamc@72 498 (match a_eq_dec x x' with
adamc@72 499 | true -> true
adamc@72 500 | false -> in_dec a_eq_dec x ls')
adamc@72 501 \end{verbatim}%
adamc@72 502
adamc@72 503 #<pre>
adamc@72 504 (** val in_dec : ('a1 -> 'a1 -> bool) -> 'a1 -> 'a1 list -> bool **)
adamc@72 505
adamc@72 506 let rec in_dec a_eq_dec x = function
adamc@72 507 | Nil -> false
adamc@72 508 | Cons (x', ls') ->
adamc@72 509 (match a_eq_dec x x' with
adamc@72 510 | true -> true
adamc@72 511 | false -> in_dec a_eq_dec x ls')
adamc@72 512 </pre># *)
adamc@72 513
adamc@72 514
adamc@72 515 (** * Partial Subset Types *)
adamc@72 516
adamc@73 517 (** 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 that than returning a default value, as [pred] does for [0]. One approach is to define this type family [maybe], which is a version of [sig] that allows obligation-free failure. *)
adamc@73 518
adamc@89 519 Inductive maybe (A : Set) (P : A -> Prop) : Set :=
adamc@72 520 | Unknown : maybe P
adamc@72 521 | Found : forall x : A, P x -> maybe P.
adamc@72 522
adamc@73 523 (** We can define some new notations, analogous to those we defined for subset types. *)
adamc@73 524
adamc@72 525 Notation "{{ x | P }}" := (maybe (fun x => P)).
adamc@72 526 Notation "??" := (Unknown _).
adamc@72 527 Notation "[[ x ]]" := (Found _ x _).
adamc@72 528
adamc@73 529 (** Now our next version of [pred] is trivial to write. *)
adamc@73 530
adamc@212 531 Definition pred_strong7 (n : nat) : {{m | n = S m}}.
adamc@73 532 refine (fun n =>
adamc@212 533 match n with
adamc@73 534 | O => ??
adamc@73 535 | S n' => [[n']]
adamc@73 536 end); trivial.
adamc@73 537 Defined.
adamc@73 538
adam@282 539 Eval compute in pred_strong7 2.
adam@282 540 (** %\vspace{-.15in}% [[
adam@282 541 = [[1]]
adam@282 542 : {{m | 2 = S m}}
adam@282 543
adam@282 544 ]] *)
adam@282 545
adam@282 546 Eval compute in pred_strong7 0.
adam@282 547 (** %\vspace{-.15in}% [[
adam@282 548 = ??
adam@282 549 : {{m | 0 = S m}}
adam@282 550
adam@282 551 ]]
adam@282 552
adam@282 553 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 [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 554
adamc@73 555 Print sumor.
adamc@212 556 (** %\vspace{-.15in}% [[
adamc@73 557 Inductive sumor (A : Type) (B : Prop) : Type :=
adamc@73 558 inleft : A -> A + {B} | inright : B -> A + {B}
adamc@73 559 For inleft: Argument A is implicit
adamc@73 560 For inright: Argument B is implicit
adamc@73 561 ]] *)
adamc@73 562
adamc@73 563 (** 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 564
adamc@73 565 Notation "!!" := (inright _ _).
adamc@73 566 Notation "[[[ x ]]]" := (inleft _ [x]).
adamc@73 567
adamc@73 568 (** 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 569
adamc@212 570 Definition pred_strong8 (n : nat) : {m : nat | n = S m} + {n = 0}.
adamc@73 571 refine (fun n =>
adamc@212 572 match n with
adamc@73 573 | O => !!
adamc@73 574 | S n' => [[[n']]]
adamc@73 575 end); trivial.
adamc@73 576 Defined.
adamc@73 577
adam@282 578 Eval compute in pred_strong8 2.
adam@282 579 (** %\vspace{-.15in}% [[
adam@282 580 = [[[1]]]
adam@282 581 : {m : nat | 2 = S m} + {2 = 0}
adam@282 582
adam@282 583 ]] *)
adam@282 584
adam@282 585 Eval compute in pred_strong8 0.
adam@282 586 (** %\vspace{-.15in}% [[
adam@282 587 = !!
adam@282 588 : {m : nat | 0 = S m} + {0 = 0}
adam@282 589
adam@282 590 ]] *)
adam@282 591
adamc@73 592
adamc@73 593 (** * Monadic Notations *)
adamc@73 594
adamc@73 595 (** We can treat [maybe] like a monad, in the same way that the Haskell [Maybe] type is interpreted as a failure monad. Our [maybe] has the wrong type to be a literal monad, but a "bind"-like notation will still be helpful. *)
adamc@73 596
adamc@72 597 Notation "x <- e1 ; e2" := (match e1 with
adamc@72 598 | Unknown => ??
adamc@72 599 | Found x _ => e2
adamc@72 600 end)
adamc@72 601 (right associativity, at level 60).
adamc@72 602
adamc@73 603 (** The meaning of [x <- e1; e2] is: First run [e1]. If it fails to find an answer, then announce failure for our derived computation, too. If [e1] %\textit{%#<i>#does#</i>#%}% find an answer, pass that answer on to [e2] to find the final result. The variable [x] can be considered bound in [e2].
adamc@73 604
adamc@73 605 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 606
adamc@73 607 Definition doublePred (n1 n2 : nat) : {{p | n1 = S (fst p) /\ n2 = S (snd p)}}.
adamc@73 608 refine (fun n1 n2 =>
adamc@212 609 m1 <- pred_strong7 n1;
adamc@212 610 m2 <- pred_strong7 n2;
adamc@73 611 [[(m1, m2)]]); tauto.
adamc@73 612 Defined.
adamc@73 613
adamc@73 614 (** We can build a [sumor] version of the "bind" notation and use it to write a similarly straightforward version of this function. *)
adamc@73 615
adamc@73 616 (** printing <-- $\longleftarrow$ *)
adamc@73 617
adamc@73 618 Notation "x <-- e1 ; e2" := (match e1 with
adamc@73 619 | inright _ => !!
adamc@73 620 | inleft (exist x _) => e2
adamc@73 621 end)
adamc@73 622 (right associativity, at level 60).
adamc@73 623
adamc@73 624 (** printing * $\times$ *)
adamc@73 625
adamc@212 626 Definition doublePred' (n1 n2 : nat)
adamc@212 627 : {p : nat * nat | n1 = S (fst p) /\ n2 = S (snd p)}
adamc@73 628 + {n1 = 0 \/ n2 = 0}.
adamc@73 629 refine (fun n1 n2 =>
adamc@212 630 m1 <-- pred_strong8 n1;
adamc@212 631 m2 <-- pred_strong8 n2;
adamc@73 632 [[[(m1, m2)]]]); tauto.
adamc@73 633 Defined.
adamc@72 634
adamc@72 635
adamc@72 636 (** * A Type-Checking Example *)
adamc@72 637
adamc@75 638 (** We can apply these specification types to build a certified type-checker for a simple expression language. *)
adamc@75 639
adamc@72 640 Inductive exp : Set :=
adamc@72 641 | Nat : nat -> exp
adamc@72 642 | Plus : exp -> exp -> exp
adamc@72 643 | Bool : bool -> exp
adamc@72 644 | And : exp -> exp -> exp.
adamc@72 645
adamc@75 646 (** We define a simple language of types and its typing rules, in the style introduced in Chapter 4. *)
adamc@75 647
adamc@72 648 Inductive type : Set := TNat | TBool.
adamc@72 649
adamc@72 650 Inductive hasType : exp -> type -> Prop :=
adamc@72 651 | HtNat : forall n,
adamc@72 652 hasType (Nat n) TNat
adamc@72 653 | HtPlus : forall e1 e2,
adamc@72 654 hasType e1 TNat
adamc@72 655 -> hasType e2 TNat
adamc@72 656 -> hasType (Plus e1 e2) TNat
adamc@72 657 | HtBool : forall b,
adamc@72 658 hasType (Bool b) TBool
adamc@72 659 | HtAnd : forall e1 e2,
adamc@72 660 hasType e1 TBool
adamc@72 661 -> hasType e2 TBool
adamc@72 662 -> hasType (And e1 e2) TBool.
adamc@72 663
adamc@75 664 (** It will be helpful to have a function for comparing two types. We build one using [decide equality]. *)
adamc@75 665
adamc@77 666 (* begin thide *)
adamc@75 667 Definition eq_type_dec : forall t1 t2 : type, {t1 = t2} + {t1 <> t2}.
adamc@72 668 decide equality.
adamc@72 669 Defined.
adamc@72 670
adamc@212 671 (** 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 672
adamc@73 673 Notation "e1 ;; e2" := (if e1 then e2 else ??)
adamc@73 674 (right associativity, at level 60).
adamc@73 675
adamc@75 676 (** 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 677 (* end thide *)
adamc@75 678
adamc@72 679 Definition typeCheck (e : exp) : {{t | hasType e t}}.
adamc@77 680 (* begin thide *)
adamc@72 681 Hint Constructors hasType.
adamc@72 682
adamc@72 683 refine (fix F (e : exp) : {{t | hasType e t}} :=
adamc@212 684 match e with
adamc@72 685 | Nat _ => [[TNat]]
adamc@72 686 | Plus e1 e2 =>
adamc@72 687 t1 <- F e1;
adamc@72 688 t2 <- F e2;
adamc@72 689 eq_type_dec t1 TNat;;
adamc@72 690 eq_type_dec t2 TNat;;
adamc@72 691 [[TNat]]
adamc@72 692 | Bool _ => [[TBool]]
adamc@72 693 | And e1 e2 =>
adamc@72 694 t1 <- F e1;
adamc@72 695 t2 <- F e2;
adamc@72 696 eq_type_dec t1 TBool;;
adamc@72 697 eq_type_dec t2 TBool;;
adamc@72 698 [[TBool]]
adamc@72 699 end); crush.
adamc@77 700 (* end thide *)
adamc@72 701 Defined.
adamc@72 702
adamc@75 703 (** Despite manipulating proofs, our type checker is easy to run. *)
adamc@75 704
adamc@72 705 Eval simpl in typeCheck (Nat 0).
adamc@212 706 (** %\vspace{-.15in}% [[
adamc@75 707 = [[TNat]]
adamc@75 708 : {{t | hasType (Nat 0) t}}
adamc@75 709 ]] *)
adamc@75 710
adamc@72 711 Eval simpl in typeCheck (Plus (Nat 1) (Nat 2)).
adamc@212 712 (** %\vspace{-.15in}% [[
adamc@75 713 = [[TNat]]
adamc@75 714 : {{t | hasType (Plus (Nat 1) (Nat 2)) t}}
adamc@75 715 ]] *)
adamc@75 716
adamc@72 717 Eval simpl in typeCheck (Plus (Nat 1) (Bool false)).
adamc@212 718 (** %\vspace{-.15in}% [[
adamc@75 719 = ??
adamc@75 720 : {{t | hasType (Plus (Nat 1) (Bool false)) t}}
adamc@75 721 ]] *)
adamc@75 722
adamc@75 723 (** The type-checker also extracts to some reasonable OCaml code. *)
adamc@75 724
adamc@75 725 Extraction typeCheck.
adamc@75 726
adamc@75 727 (** %\begin{verbatim}
adamc@75 728 (** val typeCheck : exp -> type0 maybe **)
adamc@75 729
adamc@75 730 let rec typeCheck = function
adamc@75 731 | Nat n -> Found TNat
adamc@75 732 | Plus (e1, e2) ->
adamc@75 733 (match typeCheck e1 with
adamc@75 734 | Unknown -> Unknown
adamc@75 735 | Found t1 ->
adamc@75 736 (match typeCheck e2 with
adamc@75 737 | Unknown -> Unknown
adamc@75 738 | Found t2 ->
adamc@75 739 (match eq_type_dec t1 TNat with
adamc@75 740 | true ->
adamc@75 741 (match eq_type_dec t2 TNat with
adamc@75 742 | true -> Found TNat
adamc@75 743 | false -> Unknown)
adamc@75 744 | false -> Unknown)))
adamc@75 745 | Bool b -> Found TBool
adamc@75 746 | And (e1, e2) ->
adamc@75 747 (match typeCheck e1 with
adamc@75 748 | Unknown -> Unknown
adamc@75 749 | Found t1 ->
adamc@75 750 (match typeCheck e2 with
adamc@75 751 | Unknown -> Unknown
adamc@75 752 | Found t2 ->
adamc@75 753 (match eq_type_dec t1 TBool with
adamc@75 754 | true ->
adamc@75 755 (match eq_type_dec t2 TBool with
adamc@75 756 | true -> Found TBool
adamc@75 757 | false -> Unknown)
adamc@75 758 | false -> Unknown)))
adamc@75 759 \end{verbatim}%
adamc@75 760
adamc@75 761 #<pre>
adamc@75 762 (** val typeCheck : exp -> type0 maybe **)
adamc@75 763
adamc@75 764 let rec typeCheck = function
adamc@75 765 | Nat n -> Found TNat
adamc@75 766 | Plus (e1, e2) ->
adamc@75 767 (match typeCheck e1 with
adamc@75 768 | Unknown -> Unknown
adamc@75 769 | Found t1 ->
adamc@75 770 (match typeCheck e2 with
adamc@75 771 | Unknown -> Unknown
adamc@75 772 | Found t2 ->
adamc@75 773 (match eq_type_dec t1 TNat with
adamc@75 774 | true ->
adamc@75 775 (match eq_type_dec t2 TNat with
adamc@75 776 | true -> Found TNat
adamc@75 777 | false -> Unknown)
adamc@75 778 | false -> Unknown)))
adamc@75 779 | Bool b -> Found TBool
adamc@75 780 | And (e1, e2) ->
adamc@75 781 (match typeCheck e1 with
adamc@75 782 | Unknown -> Unknown
adamc@75 783 | Found t1 ->
adamc@75 784 (match typeCheck e2 with
adamc@75 785 | Unknown -> Unknown
adamc@75 786 | Found t2 ->
adamc@75 787 (match eq_type_dec t1 TBool with
adamc@75 788 | true ->
adamc@75 789 (match eq_type_dec t2 TBool with
adamc@75 790 | true -> Found TBool
adamc@75 791 | false -> Unknown)
adamc@75 792 | false -> Unknown)))
adamc@75 793 </pre># *)
adamc@75 794
adamc@75 795 (** %\smallskip%
adamc@75 796
adamc@75 797 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 798
adamc@77 799 (* begin thide *)
adamc@73 800 Notation "e1 ;;; e2" := (if e1 then e2 else !!)
adamc@73 801 (right associativity, at level 60).
adamc@73 802
adamc@75 803 (** Next, we prove a helpful lemma, which states that a given expression can have at most one type. *)
adamc@75 804
adamc@75 805 Lemma hasType_det : forall e t1,
adamc@73 806 hasType e t1
adamc@73 807 -> forall t2,
adamc@73 808 hasType e t2
adamc@73 809 -> t1 = t2.
adamc@73 810 induction 1; inversion 1; crush.
adamc@73 811 Qed.
adamc@73 812
adamc@75 813 (** Now we can define the type-checker. Its type expresses that it only fails on untypable expressions. *)
adamc@75 814
adamc@77 815 (* end thide *)
adamc@212 816 Definition typeCheck' (e : exp) : {t : type | hasType e t} + {forall t, ~ hasType e t}.
adamc@77 817 (* begin thide *)
adamc@73 818 Hint Constructors hasType.
adamc@75 819 (** We register all of the typing rules as hints. *)
adamc@75 820
adamc@73 821 Hint Resolve hasType_det.
adamc@75 822 (** [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 823
adamc@75 824 (** Finally, the implementation of [typeCheck] can be transcribed literally, simply switching notations as needed. *)
adamc@212 825
adamc@212 826 refine (fix F (e : exp) : {t : type | hasType e t} + {forall t, ~ hasType e t} :=
adamc@212 827 match e with
adamc@73 828 | Nat _ => [[[TNat]]]
adamc@73 829 | Plus e1 e2 =>
adamc@73 830 t1 <-- F e1;
adamc@73 831 t2 <-- F e2;
adamc@73 832 eq_type_dec t1 TNat;;;
adamc@73 833 eq_type_dec t2 TNat;;;
adamc@73 834 [[[TNat]]]
adamc@73 835 | Bool _ => [[[TBool]]]
adamc@73 836 | And e1 e2 =>
adamc@73 837 t1 <-- F e1;
adamc@73 838 t2 <-- F e2;
adamc@73 839 eq_type_dec t1 TBool;;;
adamc@73 840 eq_type_dec t2 TBool;;;
adamc@73 841 [[[TBool]]]
adamc@73 842 end); clear F; crush' tt hasType; eauto.
adamc@75 843
adamc@75 844 (** We clear [F], the local name for the recursive function, to avoid strange proofs that refer to recursive calls that we never make. The [crush] variant [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 845 (* end thide *)
adamc@212 846
adamc@212 847
adamc@73 848 Defined.
adamc@73 849
adamc@75 850 (** 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 851
adamc@75 852 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. *)
adamc@75 853
adamc@73 854 Eval simpl in typeCheck' (Nat 0).
adamc@212 855 (** %\vspace{-.15in}% [[
adamc@75 856 = [[[TNat]]]
adamc@75 857 : {t : type | hasType (Nat 0) t} +
adamc@75 858 {(forall t : type, ~ hasType (Nat 0) t)}
adamc@75 859 ]] *)
adamc@75 860
adamc@73 861 Eval simpl in typeCheck' (Plus (Nat 1) (Nat 2)).
adamc@212 862 (** %\vspace{-.15in}% [[
adamc@75 863 = [[[TNat]]]
adamc@75 864 : {t : type | hasType (Plus (Nat 1) (Nat 2)) t} +
adamc@75 865 {(forall t : type, ~ hasType (Plus (Nat 1) (Nat 2)) t)}
adamc@75 866 ]] *)
adamc@75 867
adamc@73 868 Eval simpl in typeCheck' (Plus (Nat 1) (Bool false)).
adamc@212 869 (** %\vspace{-.15in}% [[
adamc@75 870 = !!
adamc@75 871 : {t : type | hasType (Plus (Nat 1) (Bool false)) t} +
adamc@75 872 {(forall t : type, ~ hasType (Plus (Nat 1) (Bool false)) t)}
adamc@75 873 ]] *)
adamc@82 874
adamc@82 875
adamc@82 876 (** * Exercises *)
adamc@82 877
adamc@82 878 (** All of the notations defined in this chapter, plus some extras, are available for import from the module [MoreSpecif] of the book source.
adamc@82 879
adamc@82 880 %\begin{enumerate}%#<ol>#
adamc@82 881 %\item%#<li># Write a function of type [forall n m : nat, {n <= m} + {n > m}]. That is, this function decides whether one natural is less than another, and its dependent type guarantees that its results are accurate.#</li>#
adamc@82 882
adamc@82 883 %\item%#<li># %\begin{enumerate}%#<ol>#
adamc@82 884 %\item%#<li># Define [var], a type of propositional variables, as a synonym for [nat].#</li>#
adamc@82 885 %\item%#<li># Define an inductive type [prop] of propositional logic formulas, consisting of variables, negation, and binary conjunction and disjunction.#</li>#
adamc@82 886 %\item%#<li># Define a function [propDenote] from variable truth assignments and [prop]s to [Prop], based on the usual meanings of the connectives. Represent truth assignments as functions from [var] to [bool].#</li>#
adamc@82 887 %\item%#<li># Define a function [bool_true_dec] that checks whether a boolean is true, with a maximally expressive dependent type. That is, the function should have type [forall b, {b = true} + {b = true -> False}]. #</li>#
adamc@212 888 %\item%#<li># Define a function [decide] that determines whether a particular [prop] is true under a particular truth assignment. That is, the function should have type [forall (truth : var -> bool) (p : prop), {propDenote truth p} + {~ propDenote truth p}]. This function is probably easiest to write in the usual tactical style, instead of programming with [refine]. [bool_true_dec] may come in handy as a hint.#</li>#
adamc@212 889 %\item%#<li># Define a function [negate] that returns a simplified version of the negation of a [prop]. That is, the function should have type [forall p : prop, {p' : prop | forall truth, propDenote truth p <-> ~ propDenote truth p'}]. To simplify a variable, just negate it. Simplify a negation by returning its argument. Simplify conjunctions and disjunctions using De Morgan's laws, negating the arguments recursively and switching the kind of connective. [decide] may be useful in some of the proof obligations, even if you do not use it in the computational part of [negate]'s definition. Lemmas like [decide] allow us to compensate for the lack of a general Law of the Excluded Middle in CIC.#</li>#
adamc@82 890 #</ol>#%\end{enumerate}% #</li>#
adamc@82 891
adamc@212 892 %\item%#<li># Implement the DPLL satisfiability decision procedure for boolean formulas in conjunctive normal form, with a dependent type that guarantees its correctness. An example of a reasonable type for this function would be [forall f : formula, {truth : tvals | formulaTrue truth f} + {forall truth, ~ formulaTrue truth f}]. Implement at least "the basic backtracking algorithm" as defined here:
adamc@82 893 %\begin{center}\url{http://en.wikipedia.org/wiki/DPLL_algorithm}\end{center}%
adamc@82 894 #<blockquote><a href="http://en.wikipedia.org/wiki/DPLL_algorithm">http://en.wikipedia.org/wiki/DPLL_algorithm</a></blockquote>#
adamc@82 895 It might also be instructive to implement the unit propagation and pure literal elimination optimizations described there or some other optimizations that have been used in modern SAT solvers.#</li>#
adamc@82 896
adamc@82 897 #</ol>#%\end{enumerate}% *)