LogicLogic in Coq

Require Export MoreProp.

Coq's built-in logic is very small: the only primitives are Inductive definitions, universal quantification (), and implication (), while all the other familiar logical connectives — conjunction, disjunction, negation, existential quantification, even equality — can be encoded using just these.
This chapter explains the encodings and shows how the tactics we've seen can be used to carry out standard forms of logical reasoning involving these connectives.


The logical conjunction of propositions P and Q can be represented using an Inductive definition with one constructor.

Inductive and (P Q : Prop) : Prop :=
  conj : P Q (and P Q).

Note that, like the definition of ev in a previous chapter, this definition is parameterized; however, in this case, the parameters are themselves propositions, rather than numbers.
The intuition behind this definition is simple: to construct evidence for and P Q, we must provide evidence for P and evidence for Q. More precisely:
  • conj p q can be taken as evidence for and P Q if p is evidence for P and q is evidence for Q; and
  • this is the only way to give evidence for and P Q — that is, if someone gives us evidence for and P Q, we know it must have the form conj p q, where p is evidence for P and q is evidence for Q.
Since we'll be using conjunction a lot, let's introduce a more familiar-looking infix notation for it.

Notation "P Q" := (and P Q) : type_scope.

(The type_scope annotation tells Coq that this notation will be appearing in propositions, not values.)
Consider the "type" of the constructor conj:

Check conj.
(* ===>  forall P Q : Prop, P -> Q -> P /λ Q *)

Notice that it takes 4 inputs — namely the propositions P and Q and evidence for P and Q — and returns as output the evidence of P Q.
Besides the elegance of building everything up from a tiny foundation, what's nice about defining conjunction this way is that we can prove statements involving conjunction using the tactics that we already know. For example, if the goal statement is a conjuction, we can prove it by applying the single constructor conj, which (as can be seen from the type of conj) solves the current goal and leaves the two parts of the conjunction as subgoals to be proved separately.

Theorem and_example :
  (beautiful 0) (beautiful 3).
  apply conj.
  Case "left". apply b_0.
  Case "right". apply b_3. Qed.

Just for convenience, we can use the tactic split as a shorthand for apply conj.

Theorem and_example' :
  (ev 0) (ev 4).
    Case "left". apply ev_0.
    Case "right". apply ev_SS. apply ev_SS. apply ev_0. Qed.

Conversely, the inversion tactic can be used to take a conjunction hypothesis in the context, calculate what evidence must have been used to build it, and add variables representing this evidence to the proof context.

Theorem proj1 : P Q : Prop,
  P Q P.
  intros P Q H.
  inversion H as [HP HQ].
  apply HP. Qed.

Exercise: 1 star, optional (proj2)

Theorem proj2 : P Q : Prop,
  P Q Q.
  (* FILL IN HERE *) Admitted.

Theorem and_commut : P Q : Prop,
  P Q Q P.
  intros P Q H.
  inversion H as [HP HQ].
    Case "left". apply HQ.
    Case "right". apply HP. Qed.

Exercise: 2 stars (and_assoc)

In the following proof, notice how the nested pattern in the inversion breaks the hypothesis H : P (Q R) down into HP: P, HQ : Q, and HR : R. Finish the proof from there:

Theorem and_assoc : P Q R : Prop,
  P (Q R) (P Q) R.
  intros P Q R H.
  inversion H as [HP [HQ HR]].
(* FILL IN HERE *) Admitted.

Exercise: 2 stars (even__ev)

Now we can prove the other direction of the equivalence of even and ev, which we left hanging in chapter Prop. Notice that the left-hand conjunct here is the statement we are actually interested in; the right-hand conjunct is needed in order to make the induction hypothesis strong enough that we can carry out the reasoning in the inductive step. (To see why this is needed, try proving the left conjunct by itself and observe where things get stuck.)

Theorem even__ev : n : nat,
  (even n ev n) (even (S n) ev (S n)).
  (* Hint: Use induction on n. *)
  (* FILL IN HERE *) Admitted.


The handy "if and only if" connective is just the conjunction of two implications.

Definition iff (P Q : Prop) := (P Q) (Q P).

Notation "P Q" := (iff P Q)
                      (at level 95, no associativity)
                      : type_scope.

Theorem iff_implies : P Q : Prop,
  (P Q) P Q.
  intros P Q H.
  inversion H as [HAB HBA]. apply HAB. Qed.

Theorem iff_sym : P Q : Prop,
  (P Q) (Q P).
  intros P Q H.
  inversion H as [HAB HBA].
    Case "". apply HBA.
    Case "". apply HAB. Qed.

Exercise: 1 star, optional (iff_properties)

Using the above proof that is symmetric (iff_sym) as a guide, prove that it is also reflexive and transitive.

Theorem iff_refl : P : Prop,
  P P.
  (* FILL IN HERE *) Admitted.

Theorem iff_trans : P Q R : Prop,
  (P Q) (Q R) (P R).
  (* FILL IN HERE *) Admitted.

Hint: If you have an iff hypothesis in the context, you can use inversion to break it into two separate implications. (Think about why this works.)
Some of Coq's tactics treat iff statements specially, thus avoiding the need for some low-level manipulation when reasoning with them. In particular, rewrite can be used with iff statements, not just equalities.


Disjunction ("logical or") can also be defined as an inductive proposition.

Inductive or (P Q : Prop) : Prop :=
  | or_introl : P or P Q
  | or_intror : Q or P Q.

Notation "P Q" := (or P Q) : type_scope.

Consider the "type" of the constructor or_introl:

Check or_introl.
(* ===>  forall P Q : Prop, P -> P λ/ Q *)

It takes 3 inputs, namely the propositions P, Q and evidence of P, and returns, as output, the evidence of P Q. Next, look at the type of or_intror:

Check or_intror.
(* ===>  forall P Q : Prop, Q -> P λ/ Q *)

It is like or_introl but it requires evidence of Q instead of evidence of P.
Intuitively, there are two ways of giving evidence for P Q:
  • give evidence for P (and say that it is P you are giving evidence for — this is the function of the or_introl constructor), or
  • give evidence for Q, tagged with the or_intror constructor.
Since P Q has two constructors, doing inversion on a hypothesis of type P Q yields two subgoals.

Theorem or_commut : P Q : Prop,
  P Q Q P.
  intros P Q H.
  inversion H as [HP | HQ].
    Case "left". apply or_intror. apply HP.
    Case "right". apply or_introl. apply HQ. Qed.

From here on, we'll use the shorthand tactics left and right in place of apply or_introl and apply or_intror.

Theorem or_commut' : P Q : Prop,
  P Q Q P.
  intros P Q H.
  inversion H as [HP | HQ].
    Case "left". right. apply HP.
    Case "right". left. apply HQ. Qed.

Theorem or_distributes_over_and_1 : P Q R : Prop,
  P (Q R) (P Q) (P R).
  intros P Q R. intros H. inversion H as [HP | [HQ HR]].
    Case "left". split.
      SCase "left". left. apply HP.
      SCase "right". left. apply HP.
    Case "right". split.
      SCase "left". right. apply HQ.
      SCase "right". right. apply HR. Qed.

Exercise: 2 stars (or_distributes_over_and_2)

Theorem or_distributes_over_and_2 : P Q R : Prop,
  (P Q) (P R) P (Q R).
  (* FILL IN HERE *) Admitted.

Exercise: 1 star, optional (or_distributes_over_and)

Theorem or_distributes_over_and : P Q R : Prop,
  P (Q R) (P Q) (P R).
  (* FILL IN HERE *) Admitted.

Relating and with andb and orb (advanced)

We've already seen several places where analogous structures can be found in Coq's computational (Type) and logical (Prop) worlds. Here is one more: the boolean operators andb and orb are clearly analogs of the logical connectives and . This analogy can be made more precise by the following theorems, which show how to translate knowledge about andb and orb's behaviors on certain inputs into propositional facts about those inputs.

Theorem andb_prop : b c,
  andb b c = true b = true c = true.
  intros b c H.
  destruct b.
    Case "b = true". destruct c.
      SCase "c = true". apply conj. reflexivity. reflexivity.
      SCase "c = false". inversion H.
    Case "b = false". inversion H. Qed.

Theorem andb_true_intro : b c,
  b = true c = true andb b c = true.
  intros b c H.
  inversion H.
  rewrite H0. rewrite H1. reflexivity. Qed.

Exercise: 2 stars, optional (bool_prop)

Theorem andb_false : b c,
  andb b c = false b = false c = false.
  (* FILL IN HERE *) Admitted.

Theorem orb_prop : b c,
  orb b c = true b = true c = true.
  (* FILL IN HERE *) Admitted.

Theorem orb_false_elim : b c,
  orb b c = false b = false c = false.
  (* FILL IN HERE *) Admitted.


Logical falsehood can be represented in Coq as an inductively defined proposition with no constructors.

Inductive False : Prop := .

Intuition: False is a proposition for which there is no way to give evidence.
Since False has no constructors, inverting an assumption of type False always yields zero subgoals, allowing us to immediately prove any goal.

Theorem False_implies_nonsense :
  False 2 + 2 = 5.
  intros contra.
  inversion contra. Qed.

How does this work? The inversion tactic breaks contra into each of its possible cases, and yields a subgoal for each case. As contra is evidence for False, it has no possible cases, hence, there are no possible subgoals and the proof is done.
Conversely, the only way to prove False is if there is already something nonsensical or contradictory in the context:

Theorem nonsense_implies_False :
  2 + 2 = 5 False.
  intros contra.
  inversion contra. Qed.

Actually, since the proof of False_implies_nonsense doesn't actually have anything to do with the specific nonsensical thing being proved; it can easily be generalized to work for an arbitrary P:

Theorem ex_falso_quodlibet : (P:Prop),
  False P.
  intros P contra.
  inversion contra. Qed.

The Latin ex falso quodlibet means, literally, "from falsehood follows whatever you please." This theorem is also known as the principle of explosion.


Since we have defined falsehood in Coq, one might wonder whether it is possible to define truth in the same way. We can.

Exercise: 2 stars, advanced (True)

Define True as another inductively defined proposition. (The intution is that True should be a proposition for which it is trivial to give evidence.)

However, unlike False, which we'll use extensively, True is used fairly rarely. By itself, it is trivial (and therefore uninteresting) to prove as a goal, and it carries no useful information as a hypothesis. But it can be useful when defining complex Props using conditionals, or as a parameter to higher-order Props.


The logical complement of a proposition P is written not P or, for shorthand, ¬P:

Definition not (P:Prop) := P False.

The intuition is that, if P is not true, then anything at all (even False) follows from assuming P.

Notation "¬ x" := (not x) : type_scope.

Check not.
(* ===> Prop -> Prop *)

It takes a little practice to get used to working with negation in Coq. Even though you can see perfectly well why something is true, it can be a little hard at first to get things into the right configuration so that Coq can see it! Here are proofs of a few familiar facts about negation to get you warmed up.

Theorem not_False :
  ¬ False.
  unfold not. intros H. inversion H. Qed.

Theorem contradiction_implies_anything : P Q : Prop,
  (P ¬P) Q.
  intros P Q H. inversion H as [HP HNA]. unfold not in HNA.
  apply HNA in HP. inversion HP. Qed.

Theorem double_neg : P : Prop,
  P ~~P.
  intros P H. unfold not. intros G. apply G. apply H. Qed.

Exercise: 2 stars, advanced (double_neg_inf)

Write an informal proof of double_neg:
Theorem: P implies ~~P, for any proposition P.
Proof: (* FILL IN HERE *)

Exercise: 2 stars (contrapositive)

Theorem contrapositive : P Q : Prop,
  (P Q) Q ¬P).
  (* FILL IN HERE *) Admitted.

Exercise: 1 star (not_both_true_and_false)

Theorem not_both_true_and_false : P : Prop,
  ¬ (P ¬P).
  (* FILL IN HERE *) Admitted.

Exercise: 1 star, advanced (informal_not_PNP)

Write an informal proof (in English) of the proposition P : Prop, ~(P ¬P).


Theorem five_not_even :
  ¬ ev 5.
  unfold not. intros Hev5. inversion Hev5 as [|n Hev3 Heqn].
  inversion Hev3 as [|n' Hev1 Heqn']. inversion Hev1. Qed.

Exercise: 1 star (ev_not_ev_S)

Theorem five_not_even confirms the unsurprising fact that five is not an even number. Prove this more interesting fact:

Theorem ev_not_ev_S : n,
  ev n ¬ ev (S n).
  unfold not. intros n H. induction H. (* not n! *)
  (* FILL IN HERE *) Admitted.
Note that some theorems that are true in classical logic are not provable in Coq's (constructive) logic. E.g., let's look at how this proof gets stuck...

Theorem classic_double_neg : P : Prop,
  ~~P P.
  intros P H. unfold not in H.
  (* But now what? There is no way to "invent" evidence for ¬P 
     from evidence for P. *)


Exercise: 5 stars, advanced, optional (classical_axioms)

For those who like a challenge, here is an exercise taken from the Coq'Art book (p. 123). The following five statements are often considered as characterizations of classical logic (as opposed to constructive logic, which is what is "built in" to Coq). We can't prove them in Coq, but we can consistently add any one of them as an unproven axiom if we wish to work in classical logic. Prove that these five propositions are equivalent.

Definition peirce := P Q: Prop,
Definition classic := P:Prop,
  ~~P P.
Definition excluded_middle := P:Prop,
  P ¬P.
Definition de_morgan_not_and_not := P Q:Prop,
  ~(~P ¬Q) PQ.
Definition implies_to_or := P Q:Prop,
  (PQ) PQ).


Exercise: 3 stars (excluded_middle_irrefutable)

This theorem implies that it is always safe to add a decidablity axiom (i.e. an instance of excluded middle) for any particular Prop P. Why? Because we cannot prove the negation of such an axiom; if we could, we would have both ¬ (P ¬P) and ¬ ¬ (P ¬P), a contradiction.

Theorem excluded_middle_irrefutable: (P:Prop), ¬ ¬ (P ¬ P).
  (* FILL IN HERE *) Admitted.


Saying x y is just the same as saying ~(x = y).

Notation "x ≠ y" := (¬ (x = y)) : type_scope.

Since inequality involves a negation, it again requires a little practice to be able to work with it fluently. Here is one very useful trick. If you are trying to prove a goal that is nonsensical (e.g., the goal state is false = true), apply the lemma ex_falso_quodlibet to change the goal to False. This makes it easier to use assumptions of the form ¬P that are available in the context — in particular, assumptions of the form xy.

Theorem not_false_then_true : b : bool,
  bfalse b = true.
  intros b H. destruct b.
  Case "b = true". reflexivity.
  Case "b = false".
    unfold not in H.
    apply ex_falso_quodlibet.
    apply H. reflexivity. Qed.

Exercise: 2 stars (false_beq_nat)

Theorem false_beq_nat : n m : nat,
     beq_nat n m = false.
  (* FILL IN HERE *) Admitted.

Exercise: 2 stars, optional (beq_nat_false)

Theorem beq_nat_false : n m,
  beq_nat n m = false nm.
  (* FILL IN HERE *) Admitted.

Exercise: 2 stars, optional (ble_nat_false)

Theorem ble_nat_false : n m,
  ble_nat n m = false ~(nm).
  (* FILL IN HERE *) Admitted.

Existential Quantification

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

Inductive ex (X:Type) (P : XProp) : Prop :=
  ex_intro : (witness:X), P witness ex X P.

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.)

Notation "'exists' x , p" := (ex _ (fun xp))
  (at level 200, x ident, right associativity) : type_scope.
Notation "'exists' x : X , p" := (ex _ (fun x:Xp))
  (at level 200, x ident, right associativity) : type_scope.

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.

Example exists_example_1 : n, n + (n × n) = 6.
  apply ex_intro with (witness:=2).
  reflexivity. Qed.

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.

Example exists_example_1' : n, n + (n × n) = 6.
  reflexivity. Qed.

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.)

Theorem exists_example_2 : n,
  (m, n = 4 + m)
  (o, n = 2 + o).
  intros n H.
  inversion H as [m Hm].
  (2 + m).
  apply Hm. Qed.

Exercise: 1 star, optional (english_exists)

In English, what does the proposition
      ex nat (fun n ⇒ beautiful (S n))


Exercise: 1 star (dist_not_exists)

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

Theorem dist_not_exists : (X:Type) (P : X Prop),
  (x, P x) ¬ (x, ¬ P x).
  (* FILL IN HERE *) Admitted.

Exercise: 3 stars, optional (not_exists_dist)

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

Theorem not_exists_dist :
  (X:Type) (P : X Prop),
    ¬ (x, ¬ P x) (x, P x).
  (* FILL IN HERE *) Admitted.

Exercise: 2 stars (dist_exists_or)

Prove that existential quantification distributes over disjunction.

Theorem dist_exists_or : (X:Type) (P Q : X Prop),
  (x, P x Q x) (x, P x) (x, Q x).
   (* FILL IN HERE *) Admitted.

(* Print dist_exists_or. *)


Even Coq's equality relation is not built in. It has (roughly) the following inductive definition.

Inductive eq {X:Type} : X X Prop :=
  refl_equal : x, eq x x.
Standard infix notation:

Notation "x = y" := (eq x y)
                    (at level 70, no associativity)
                    : type_scope.

The definition of = is a bit subtle. The way to think about it is that, given a set X, it defines a family of propositions "x is equal to y," indexed by pairs of values (x and y) from X. There is just one way of constructing evidence for members of this family: applying the constructor refl_equal to a type X and a value x : X yields evidence that x is equal to x.

Exercise: 2 stars (leibniz_equality)

The inductive definitions of equality corresponds to Leibniz equality: what we mean when we say "x and y are equal" is that every property on P that is true of x is also true of y.

Lemma leibniz_equality : (X : Type) (x y: X),
 x = y P : X Prop, P x P y.
(* FILL IN HERE *) Admitted.
We can use refl_equal to construct evidence that, for example, 2 = 2. Can we also use it to construct evidence that 1 + 1 = 2? Yes: indeed, it is the very same piece of evidence! The reason is that Coq treats as "the same" any two terms that are convertible according to a simple set of computation rules. These rules, which are similar to those used by Eval compute, include evaluation of function application, inlining of definitions, and simplification of matches.

Lemma four: 2 + 2 = 1 + 3.
  apply refl_equal.

The reflexivity tactic that we have used to prove equalities up to now is essentially just short-hand for apply refl_equal.

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.

Inductive sumbool (A B : Prop) : Set :=
 | left : A sumbool A B
 | right : B sumbool A B.

Notation "{ A } + { B }" := (sumbool A B) : type_scope.

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

Theorem eq_nat_dec : n m : nat, {n = m} + {nm}.
  intros n.
  induction n as [|n'].
  Case "n = 0".
    intros m.
    destruct m as [|m'].
    SCase "m = 0".
      left. reflexivity.
    SCase "m = S m'".
      right. intros contra. inversion contra.
  Case "n = S n'".
    intros m.
    destruct m as [|m'].
    SCase "m = 0".
      right. intros contra. inversion contra.
    SCase "m = S m'".
      destruct IHn' with (m := m') as [eq | neq].
      left. apply f_equal. apply eq.
      right. intros Heq. inversion Heq as [Heq']. apply neq. apply Heq'.

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.

Definition override' {X: Type} (f: natX) (k:nat) (x:X) : natX:=
  fun (k':nat) ⇒ if eq_nat_dec k k' then x else f k'.

Theorem override_same' : (X:Type) x1 k1 k2 (f : natX),
  f k1 = x1
  (override' f k1 x1) k2 = f k2.
  intros X x1 k1 k2 f. intros Hx1.
  unfold override'.
  destruct (eq_nat_dec k1 k2). (* observe what appears as a hypothesis *)
  Case "k1 = k2".
    rewrite e.
    symmetry. apply Hx1.
  Case "k1 ≠ k2".
    reflexivity. Qed.

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')

Theorem override_shadow' : (X:Type) x1 x2 k1 k2 (f : natX),
  (override' (override' f k1 x2) k1 x1) k2 = (override' f k1 x1) k2.
  (* FILL IN HERE *) Admitted.

Inversion, Again (Advanced)

We've seen inversion used with both equality hypotheses and hypotheses about inductively defined propositions. Now that we've seen that these are actually the same thing, we're in a position to take a closer look at how inversion behaves...
In general, the inversion tactic
  • takes a hypothesis H whose type P is inductively defined, and
  • for each constructor C in P's definition,
    • generates a new subgoal in which we assume H was built with C,
    • adds the arguments (premises) of C to the context of the subgoal as extra hypotheses,
    • matches the conclusion (result type) of C against the current goal and calculates a set of equalities that must hold in order for C to be applicable,
    • adds these equalities to the context (and, for convenience, rewrites them in the goal), and
    • if the equalities are not satisfiable (e.g., they involve things like S n = O), immediately solves the subgoal.
Example: If we invert a hypothesis built with or, there are two constructors, so two subgoals get generated. The conclusion (result type) of the constructor (P Q) doesn't place any restrictions on the form of P or Q, so we don't get any extra equalities in the context of the subgoal.
Example: If we invert a hypothesis built with and, there is only one constructor, so only one subgoal gets generated. Again, the conclusion (result type) of the constructor (P Q) doesn't place any restrictions on the form of P or Q, so we don't get any extra equalities in the context of the subgoal. The constructor does have two arguments, though, and these can be seen in the context in the subgoal.
Example: If we invert a hypothesis built with eq, there is again only one constructor, so only one subgoal gets generated. Now, though, the form of the refl_equal constructor does give us some extra information: it tells us that the two arguments to eq must be the same! The inversion tactic adds this fact to the context.

Exercise: 1 star, optional (dist_and_or_eq_implies_and)

Lemma dist_and_or_eq_implies_and : P Q R,
       P (Q R) Q = R PQ.
(* FILL IN HERE *) Admitted.

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.

Inductive all (X : Type) (P : X Prop) : list X Prop :=
  (* FILL IN HERE *)

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

Fixpoint forallb {X : Type} (test : X bool) (l : list X) : bool :=
  match l with
    | [] ⇒ true
    | x :: l'andb (test x) (forallb test l')

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: Xbool, 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
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...

Inductive appears_in {X:Type} (a:X) : list X Prop :=
  | ai_here : l, appears_in a (a::l)
  | ai_later : b l, appears_in a l appears_in a (b::l).

...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.

Lemma appears_in_app : (X:Type) (xs ys : list X) (x:X),
     appears_in x (xs ++ ys) appears_in x xs appears_in x ys.
  (* FILL IN HERE *) Admitted.

Lemma app_appears_in : (X:Type) (xs ys : list X) (x:X),
     appears_in x xs appears_in x ys appears_in x (xs ++ ys).
  (* FILL IN HERE *) Admitted.

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 (except from your study group partner, if you have one).
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.)

Inductive nostutter: list nat Prop :=

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.

Example test_nostutter_1: nostutter [3;1;4;1;5;6].
(* FILL IN HERE *) Admitted.
  Proof. repeat constructor; apply beq_nat_false; auto. Qed.

Example test_nostutter_2: nostutter [].
(* FILL IN HERE *) Admitted.
  Proof. repeat constructor; apply beq_nat_false; auto. Qed.

Example test_nostutter_3: nostutter [5].
(* FILL IN HERE *) Admitted.
  Proof. repeat constructor; apply beq_nat_false; auto. Qed.

Example test_nostutter_4: not (nostutter [3;1;1;4]).
(* FILL IN HERE *) Admitted.
  Proof. intro.
  repeat match goal with 
    h: nostutter _ |- _ => inversion h; clear h; subst 
  contradiction H1; auto. Qed.

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).

Lemma app_length : (X:Type) (l1 l2 : list X),
  length (l1 ++ l2) = length l1 + length l2.
  (* FILL IN HERE *) Admitted.

Lemma appears_in_app_split : (X:Type) (x:X) (l:list X),
  appears_in x l
  l1, l2, l = l1 ++ (x::l2).
  (* FILL IN HERE *) Admitted.

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).

Inductive repeats {X:Type} : list X Prop :=
  (* FILL IN HERE *)

Now here's a way to formalize the pigeonhole principle. List l2 represents a list of pigeonhole labels, and list l1 represents an assignment of items to labels: if there are more items than labels, at least two items must have the same label. You will almost certainly need to use the excluded_middle hypothesis.

Theorem pigeonhole_principle: (X:Type) (l1 l2:list X),
  (x, appears_in x l1 appears_in x l2)
  length l2 < length l1
  repeats l1.
Proof. intros X l1. induction l1.
  (* FILL IN HERE *) Admitted.

(* $Date: 2013-07-30 12:24:33 -0400 (Tue, 30 Jul 2013) $ *)