MapsTotal and Partial Maps
The Coq Standard Library
Require Import Coq.Arith.Arith.
Require Import Coq.Bool.Bool.
Require Import Coq.Logic.FunctionalExtensionality.
Documentation for the standard library can be found at
http://coq.inria.fr/library/.
The SearchAbout command is a good way to look for theorems
involving objects of specific types.
Identifiers
Inductive id : Type :=
| Id : nat → id.
Definition beq_id id1 id2 :=
match id1,id2 with
| Id n1, Id n2 ⇒ beq_nat n1 n2
end.
Theorem beq_id_refl : ∀id, true = beq_id id id.
(In the HTML version, the proof of this theorem is elided, since
the details are pretty routine at this point. Click on the box if
you want to see it.)
The following useful property of beq_id follows from an
analogous lemma about numbers:
Theorem beq_id_true_iff : ∀id1 id2 : id,
beq_id id1 id2 = true ↔ id1 = id2.
Proof.
intros [n1] [n2].
unfold beq_id.
rewrite beq_nat_true_iff.
split.
- (* -> *) intros H. rewrite H. reflexivity.
- (* <- *) intros H. inversion H. reflexivity.
Qed.
intros [n1] [n2].
unfold beq_id.
rewrite beq_nat_true_iff.
split.
- (* -> *) intros H. rewrite H. reflexivity.
- (* <- *) intros H. inversion H. reflexivity.
Qed.
Similarly:
This useful variant follows just by rewriting:
Total Maps
Intuitively, a total map over an element type A is just a
function that can be used to look up ids, yielding As.
The function t_empty yields an empty total map, given a default
element; this map always returns the default element when applied
to any id.
More interesting is the update function, which (as before) takes
a map m, a key x, and a value v and returns a new map that
takes x to v and takes every other key to whatever m does.
Definition t_update {A:Type} (m : total_map A)
(x : id) (v : A) :=
fun x' ⇒ if beq_id x x' then v else m x'.
This definition is a nice example of higher-order programming.
The t_update function takes a function m and yields a new
function fun x' ⇒ ... that behaves like the desired map.
For example, we can build a map taking ids to bools, where Id
3 is mapped to true and every other key is mapped to false,
like this:
This completes the definition of total maps. Note that we don't
need to define a find operation because it is just function
application!
Example update_example1 : examplemap (Id 0) = false.
Proof. reflexivity. Qed.
Example update_example2 : examplemap (Id 1) = false.
Proof. reflexivity. Qed.
Example update_example3 : examplemap (Id 2) = false.
Proof. reflexivity. Qed.
Example update_example4 : examplemap (Id 3) = true.
Proof. reflexivity. Qed.
To use maps in later chapters, we'll need several fundamental
facts about how they behave. Even if you don't work the following
exercises, make sure you thoroughly understand the statements of
the lemmas! (Some of the proofs require the functional
extensionality axiom discussed in the Logic chapter, which is
also included in the standard library.)
Exercise: 2 stars, optional (t_update_eq)
First, if we update a map m at a key x with a new value v and then look up x in the map resulting from the update, we get back v:Lemma t_update_eq : ∀A (m: total_map A) x v,
(t_update m x v) x = v.
Proof.
(* FILL IN HERE *) Admitted.
☐
Exercise: 2 stars, optional (t_update_neq)
On the other hand, if we update a map m at a key x1 and then look up a different key x2 in the resulting map, we get the same result that m would have given:Theorem t_update_neq : ∀(X:Type) v x1 x2
(m : total_map X),
x1 ≠ x2 →
(t_update m x1 v) x2 = m x2.
Proof.
(* FILL IN HERE *) Admitted.
☐
Exercise: 2 stars, optional (t_update_shadow)
If we update a map m at a key x with a value v1 and then update again with the same key x and another value v2, the resulting map behaves the same (gives the same result when applied to any key) as the simpler map obtained by performing just the second update on m:Lemma t_update_shadow : ∀A (m: total_map A) v1 v2 x,
t_update (t_update m x v1) x v2
= t_update m x v2.
Proof.
(* FILL IN HERE *) Admitted.
☐
For the final two lemmas about total maps, it's convenient to use
the reflection idioms introduced in chapter IndProp. We begin
by proving a fundamental reflection lemma relating the equality
proposition on ids with the boolean function beq_id.
Exercise: 2 stars (beq_idP)
Use the proof of beq_natP in chapter IndProp as a template to prove the following:
☐
Now, given ids x1 and x2, we can use the destruct (beq_idP
x1 x2) to simultaneously perform case analysis on the result of
beq_id x1 x2 and generate hypotheses about the equality (in the
sense of =) of x1 and x2.
Exercise: 2 stars (t_update_same)
Using the example in chapter IndProp as a template, use beq_idP to prove the following theorem, which states that if we update a map to assign key x the same value as it already has in m, then the result is equal to m:Theorem t_update_same : ∀X x (m : total_map X),
t_update m x (m x) = m.
Proof.
(* FILL IN HERE *) Admitted.
☐
Exercise: 3 stars, recommended (t_update_permute)
Use beq_idP to prove one final property of the update function: If we update a map m at two distinct keys, it doesn't matter in which order we do the updates.Theorem t_update_permute : ∀(X:Type) v1 v2 x1 x2
(m : total_map X),
x2 ≠ x1 →
(t_update (t_update m x2 v2) x1 v1)
= (t_update (t_update m x1 v1) x2 v2).
Proof.
(* FILL IN HERE *) Admitted.
☐
Partial maps
Definition partial_map (A:Type) := total_map (option A).
Definition empty {A:Type} : partial_map A :=
t_empty None.
Definition update {A:Type} (m : partial_map A)
(x : id) (v : A) :=
t_update m x (Some v).
We can now lift all of the basic lemmas about total maps to
partial maps.
Lemma update_eq : ∀A (m: partial_map A) x v,
(update m x v) x = Some v.
Theorem update_neq : ∀(X:Type) v x1 x2
(m : partial_map X),
x2 ≠ x1 →
(update m x2 v) x1 = m x1.
Lemma update_shadow : ∀A (m: partial_map A) v1 v2 x,
update (update m x v1) x v2 = update m x v2.
Theorem update_same : ∀X v x (m : partial_map X),
m x = Some v →
update m x v = m.
Theorem update_permute : ∀(X:Type) v1 v2 x1 x2
(m : partial_map X),
x2 ≠ x1 →
(update (update m x2 v2) x1 v1)
= (update (update m x1 v1) x2 v2).