Existential Quantification

Another critical logical connective is existential quantification. We can express it with the following definition:

That is, ex is a family of propositions indexed by a type X and a property P over X. In order to give evidence for the assertion "there exists an x for which the property P holds" we must actually name a witness — a specific value x — and then give evidence for P x, i.e., evidence that x has the property P.

Coq's Notation facility can be used to introduce more familiar notation for writing existentially quantified propositions, exactly parallel to the built-in syntax for universally quantified propositions. Instead of writing ex nat ev to express the proposition that there exists some number that is even, for example, we can write ∃ x:nat, ev x. (It is not necessary to understand exactly how the Notation definition works.)

We can use the usual set of tactics for manipulating existentials. For example, to prove an existential, we can apply the constructor ex_intro. Since the premise of ex_intro involves a variable (witness) that does not appear in its conclusion, we need to explicitly give its value when we use apply.

Note that we have to explicitly give the witness.

Or, instead of writing apply ex_intro with (witness:=e) all the time, we can use the convenient shorthand ∃ e, which means the same thing.

Conversely, if we have an existential hypothesis in the context, we can eliminate it with inversion. Note the use of the as... pattern to name the variable that Coq introduces to name the witness value and get evidence that the hypothesis holds for the witness. (If we don't explicitly choose one, Coq will just call it witness, which makes proofs confusing.)

Here is another example of how to work with existentials.

Exercise: 1 star, optional (english_exists)

In English, what does the proposition mean?

Exercise: 1 star (dist_not_exists)

Prove that "P holds for all x" implies "there is no x for which P does not hold."

☐

Exercise: 3 stars, optional (not_exists_dist)

(The other direction of this theorem requires the classical "law of the excluded middle".)

☐

Exercise: 2 stars (dist_exists_or)

Prove that existential quantification distributes over disjunction.

☐

Evidence-Carrying Booleans

So far we've seen two different forms of equality predicates: eq, which produces a Prop, and the type-specific forms, like beq_nat, that produce boolean values. The former are more convenient to reason about, but we've relied on the latter to let us use equality tests in computations. While it is straightforward to write lemmas (e.g. beq_nat_true and beq_nat_false) that connect the two forms, using these lemmas quickly gets tedious.

It turns out that we can get the benefits of both forms at once by using a construct called sumbool.

Think of sumbool as being like the boolean type, but instead of its values being just true and false, they carry evidence of truth or falsity. This means that when we destruct them, we are left with the relevant evidence as a hypothesis — just as with or. (In fact, the definition of sumbool is almost the same as for or. The only difference is that values of sumbool are declared to be in Set rather than in Prop; this is a technical distinction that allows us to compute with them.)

Here's how we can define a sumbool for equality on nats

Read as a theorem, this says that equality on nats is decidable: that is, given two nat values, we can always produce either evidence that they are equal or evidence that they are not. Read computationally, eq_nat_dec takes two nat values and returns a sumbool constructed with left if they are equal and right if they are not; this result can be tested with a match or, better, with an if-then-else, just like a regular boolean. (Notice that we ended this proof with Defined rather than Qed. The only difference this makes is that the proof becomes transparent, meaning that its definition is available when Coq tries to do reductions, which is important for the computational interpretation.)

Here's a simple example illustrating the advantages of the sumbool form.

Compare this to the more laborious proof (in MoreCoq.v) for the version of override defined using beq_nat, where we had to use the auxiliary lemma beq_nat_true to convert a fact about booleans to a Prop.

Exercise: 1 star (override_shadow')

☐

Additional Exercises

Exercise: 3 stars (all_forallb)

Inductively define a property all of lists, parameterized by a type X and a property P : X → Prop, such that all X P l asserts that P is true for every element of the list l.

Recall the function forallb, from the exercise forall_exists_challenge in chapter Poly:

Using the property all, write down a specification for forallb, and prove that it satisfies the specification. Try to make your specification as precise as possible. Are there any important properties of the function forallb which are not captured by your specification?

☐

Exercise: 4 stars, advanced (filter_challenge)

One of the main purposes of Coq is to prove that programs match their specifications. To this end, let's prove that our definition of filter matches a specification. Here is the specification, written out informally in English. Suppose we have a set X, a function test: X→bool, and a list l of type list X. Suppose further that l is an "in-order merge" of two lists, l1 and l2, such that every item in l1 satisfies test and no item in l2 satisfies test. Then filter test l = l1. A list l is an "in-order merge" of l1 and l2 if it contains all the same elements as l1 and l2, in the same order as l1 and l2, but possibly interleaved. For example, is an in-order merge of and Your job is to translate this specification into a Coq theorem and prove it. (Hint: You'll need to begin by defining what it means for one list to be a merge of two others. Do this with an inductive relation, not a Fixpoint.)

☐

Exercise: 5 stars, advanced, optional (filter_challenge_2)

A different way to formally characterize the behavior of filter goes like this: Among all subsequences of l with the property that test evaluates to true on all their members, filter test l is the longest. Express this claim formally and prove it.

☐

Exercise: 4 stars, advanced (no_repeats)

The following inductively defined proposition...

...gives us a precise way of saying that a value a appears at least once as a member of a list l. Here's a pair of warm-ups about appears_in.

Now use appears_in to define a proposition disjoint X l1 l2, which should be provable exactly when l1 and l2 are lists (with elements of type X) that have no elements in common.

Next, use appears_in to define an inductive proposition no_repeats X l, which should be provable exactly when l is a list (with elements of type X) where every member is different from every other. For example, no_repeats nat [1,2,3,4] and no_repeats bool [] should be provable, while no_repeats nat [1,2,1] and no_repeats bool [true,true] should not be.

Finally, state and prove one or more interesting theorems relating disjoint, no_repeats and ++ (list append).

☐

Exercise: 3 stars (nostutter)

Formulating inductive definitions of predicates is an important skill you'll need in this course. Try to solve this exercise without any help at all. We say that a list of numbers "stutters" if it repeats the same number consecutively. The predicate "nostutter mylist" means that mylist does not stutter. Formulate an inductive definition for nostutter. (This is different from the no_repeats predicate in the exercise above; the sequence 1;4;1 repeats but does not stutter.)

Make sure each of these tests succeeds, but you are free to change the proof if the given one doesn't work for you. Your definition might be different from mine and still correct, in which case the examples might need a different proof. The suggested proofs for the examples (in comments) use a number of tactics we haven't talked about, to try to make them robust with respect to different possible ways of defining nostutter. You should be able to just uncomment and use them as-is, but if you prefer you can also prove each example with more basic tactics.

☐

Exercise: 4 stars, advanced (pigeonhole principle)

The "pigeonhole principle" states a basic fact about counting: if you distribute more than n items into n pigeonholes, some pigeonhole must contain at least two items. As is often the case, this apparently trivial fact about numbers requires non-trivial machinery to prove, but we now have enough... First a pair of useful lemmas (we already proved these for lists of naturals, but not for arbitrary lists).

Now define a predicate repeats (analogous to no_repeats in the exercise above), such that repeats X l asserts that l contains at least one repeated element (of type X).

Now here's a way to formalize the pigeonhole principle. List l2 represents a list of pigeonhole labels, and list l1 represents the labels assigned to a list of items: if there are more items than labels, at least two items must have the same label. This proof is much easier if you use the excluded_middle hypothesis to show that appears_in is decidable, i.e. ∀ x l, (appears_in x l) ∨ ¬ (appears_in x l). However, it is also possible to make the proof go through without assuming that appears_in is decidable; if you can manage to do this, you will not need the excluded_middle hypothesis.

☐