Proof Assistant Projects
Collection
Digesting proof assistant libraries for AI ingestion.
•
84 items
•
Updated
•
3
fact
stringlengths 8
6.34k
| type
stringclasses 15
values | library
stringclasses 5
values | imports
listlengths 1
4
| filename
stringclasses 33
values | symbolic_name
stringlengths 1
59
| docstring
stringclasses 1
value |
|---|---|---|---|---|---|---|
Definitions .
Set Implicit Arguments.
Variables A B C : Set.
|
Section
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
Definitions
| |
one (C : Set) (item : C) : list C := cons item nil.
|
Definition
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
one
| |
asn (A:Set) (B:Set) : Set :=
| VarAsn : atom -> A -> asn A B
| AltAsn : B -> asn A B
.
|
Inductive
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
asn
| |
map (f1 : A -> A) (f2: B -> B) (E : list (asn A B)) : list (asn A B) :=
List.map (fun x => match x with
| VarAsn _ x a => VarAsn B x (f1 a)
| AltAsn _ b => AltAsn A (f2 b)
end) E.
|
Definition
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
map
| |
dom (A: Set) (B: Set) (E : list (asn A B)) {struct E} : atoms :=
match E with
| nil => empty
| (VarAsn _ x _) :: E' => add x (dom E')
| _ :: E' => dom E'
end.
|
Fixpoint
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
dom
| |
disjoint (E : list (asn A B)) (F : list (asn A B)) : Prop :=
Subset (inter (dom E) (dom F)) empty.
|
Definition
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
disjoint
| |
binds (x : atom) (a : A) (E : list (asn A B)) : Prop :=
List.In (VarAsn B x a) E.
|
Definition
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
binds
| |
bindsAlt (b : B) (E : list (asn A B)) : Prop :=
List.In (AltAsn A b) E.
|
Definition
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
bindsAlt
| |
uniq : list (asn A B) -> Prop :=
| uniq_nil :
uniq nil
| uniq_push : forall x a E,
uniq E ->
x `notin` dom E ->
uniq ((x ~~ a) ++ E)
| uniq_alt : forall b E,
uniq E ->
uniq (one (AltAsn A b) ++ E).
|
Inductive
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
uniq
| |
erase (E : list (asn A B)) : list B :=
match E with
| nil => nil
| (AltAsn _ b) :: E => b :: erase E
| (VarAsn _ x a) :: E => erase E
end.
Unset Implicit Arguments.
|
Fixpoint
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
erase
| |
ListProperties .
Variables X : Set.
Variables x y : X.
Variables l l1 l2 l3 : list X.
|
Section
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
ListProperties
| |
cons_app_one :
cons x l = [ x ] ++ l.
Proof. clear. reflexivity. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
cons_app_one
| |
cons_app_assoc :
(cons x l1) ++ l2 = cons x (l1 ++ l2).
Proof. clear. reflexivity. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
cons_app_assoc
| |
app_assoc :
(l1 ++ l2) ++ l3 = l1 ++ (l2 ++ l3).
Proof. clear. apply app_ass. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
app_assoc
| |
app_nil_1 :
nil ++ l = l.
Proof. clear. reflexivity. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
app_nil_1
| |
app_nil_2 :
l ++ nil = l.
Proof. clear. auto with datatypes. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
app_nil_2
| |
in_one :
List.In x [ y ] <-> x = y.
Proof. clear. simpl. intuition congruence. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
in_one
| |
in_app :
List.In x (l1 ++ l2) <-> List.In x l1 \/ List.In x l2.
Proof. clear. split; auto using in_or_app, in_app_or. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
in_app
| |
AssortedListProperties .
Variables X : Set.
Variables x y : X.
Variables l l1 l2 l3 : list X.
|
Section
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
AssortedListProperties
| |
one_eq_app :
[ x ] ++ l1 = l2 ++ l3 ->
(exists qs, l2 = x :: qs /\ l1 = qs ++ l3) \/
(l2 = nil /\ l3 = x :: l1).
Proof. simpl. auto using CoqListFacts.cons_eq_app. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
one_eq_app
| |
app_eq_one :
l2 ++ l3 = [ x ] ++ l1 ->
(exists qs, l2 = x :: qs /\ l1 = qs ++ l3) \/
(l2 = nil /\ l3 = x :: l1).
Proof. simpl. auto using CoqListFacts.app_eq_cons. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
app_eq_one
| |
nil_neq_one_mid :
nil <> l1 ++ [ x ] ++ l2.
Proof. simpl. apply List.app_cons_not_nil. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
nil_neq_one_mid
| |
one_mid_neq_nil :
l1 ++ [ x ] ++ l2 <> nil.
Proof.
intros H; symmetry in H; revert H.
simpl. apply List.app_cons_not_nil.
Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
one_mid_neq_nil
| |
Properties .
Variables A B : Set.
Variables f1 : A -> A.
Variables f2 : B -> B.
Variables x : atom.
Variables b : A.
Variables a : B.
Variables E F G : list (asn A B).
|
Section
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
Properties
| |
map_nil :
map f1 f2 nil = nil.
Proof. clear. reflexivity. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
map_nil
| |
map_consVar :
map f1 f2 ((VarAsn B x b) :: E) = (VarAsn B x (f1 b)) :: map f1 f2 E.
Proof. clear. reflexivity. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
map_consVar
| |
map_consAlt :
map f1 f2 ((AltAsn A a) :: E) = (AltAsn A (f2 a)) :: map f1 f2 E.
Proof. clear. reflexivity. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
map_consAlt
| |
map_oneVar :
map f1 f2 (one (VarAsn B x b)) = one (VarAsn B x (f1 b)).
Proof. clear. reflexivity. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
map_oneVar
| |
map_oneAlt :
map f1 f2 (one (AltAsn A a)) = one (AltAsn A (f2 a)).
Proof. clear. reflexivity. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
map_oneAlt
| |
map_app :
map f1 f2 (E ++ F) = map f1 f2 E ++ map f1 f2 F.
Proof. clear. unfold map. rewrite -> List.map_app. reflexivity. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
map_app
| |
dom_nil :
(@dom A B nil) = empty.
Proof. clear. reflexivity. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
dom_nil
| |
dom_consVar :
dom (VarAsn B x b :: E) [=] singleton x `union` dom E.
Proof. clear. simpl. fsetdec. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
dom_consVar
| |
dom_consAlt :
dom (AltAsn A a :: E) [=] dom E.
Proof. clear. simpl. fsetdec. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
dom_consAlt
| |
dom_one :
dom (one (VarAsn B x b)) [=] singleton x.
Proof. clear. simpl. fsetdec. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
dom_one
| |
dom_app :
dom (E ++ F) [=] dom E `union` dom F.
Proof. clear. induction E as [ | a ]; simpl; try (destruct a); fsetdec. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
dom_app
| |
dom_map :
dom (map f1 f2 E) [=] dom E.
Proof. clear. induction E as [ | a ]; simpl; try (destruct a); fsetdec. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
dom_map
| |
simpl_asnlist :=
autorewrite with rewr_list rewr_list_in rewr_map rewr_dom.
|
Ltac
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
simpl_asnlist
| |
Notation "simpl_asnlist" "in" hyp(H) :=
autorewrite with rewr_list rewr_list_in rewr_map rewr_dom in H.
|
Tactic
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
Notation
| |
Notation "simpl_asnlist" "in" "*" :=
autorewrite with rewr_list rewr_list_in rewr_map rewr_dom in *.
(* ********************************************************************* *)
(** ** The [rewrite_alist] tactic *)
(** The tactic [(rewrite_alist E)] replaces an association list in
the conclusion of the goal with [E]. Suitability for
replacement is determined by whether [simpl_alist] can put [E]
and the chosen environment in the same normal form, up to
convertibility's in Coq. We also define an "[in H]" variant
that performs the replacement in a hypothesis [H]. *)
|
Tactic
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
Notation
| |
Notation "rewrite_asnlist" constr(E) :=
match goal with
| |- context[?x] =>
change x with E
| |- context[?x] =>
replace x with E;
[ | try reflexivity; simpl_asnlist; reflexivity ]
end.
|
Tactic
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
Notation
| |
Notation "rewrite_asnlist" constr(E) "in" hyp(H) :=
match type of H with
| context[?x] =>
change x with E in H
| context[?x] =>
replace x with E in H;
[ | try reflexivity; simpl_asnlist; reflexivity ]
end.
(* ********************************************************************* *)
(** ** Basic facts about [disjoint] *)
|
Tactic
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
Notation
| |
BasicDisjointFacts .
Implicit Types A B C D : Set.
|
Section
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
BasicDisjointFacts
| |
disjoint_sym_1 :
forall A B (E : list (asn A B)) (F : list (asn A B)),
disjoint E F ->
disjoint F E.
Proof. unfold disjoint. fsetdec. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
disjoint_sym_1
| |
disjoint_sym :
forall A B (E : list (asn A B)) (F : list (asn A B)),
disjoint E F <-> disjoint F E.
Proof. intuition auto using disjoint_sym_1. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
disjoint_sym
| |
disjoint_one_1 :
forall A B (x : atom) (a : A) (F : list (asn A B)),
disjoint (one (VarAsn B x a)) F ->
x `notin` dom F.
Proof. unfold disjoint. intros. simpl_asnlist in *. fsetdec. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
disjoint_one_1
| |
disjoint_one_2 :
forall A B (x : atom) (a : A) (F : list (asn A B)),
x `notin` dom F ->
disjoint (one (VarAsn B x a)) F.
Proof. unfold disjoint. intros. simpl_asnlist in *. fsetdec. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
disjoint_one_2
| |
disjoint_one_l :
forall A B (x : atom) (a : A) (E : list (asn A B)),
disjoint (one (VarAsn B x a)) E <-> x `notin` dom E.
Proof. intros. unfold disjoint; simpl_asnlist; split; fsetdec. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
disjoint_one_l
| |
disjoint_one_r :
forall A B (x : atom) (a : A) (E : list (asn A B)),
disjoint E (one (VarAsn B x a)) <-> x `notin` dom E.
Proof. intros. rewrite -> disjoint_sym. apply disjoint_one_l. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
disjoint_one_r
| |
disjoint_app_1 :
forall A B (E F : list (asn A B)) (G : list (asn A B)),
disjoint (E ++ F) G ->
disjoint E G.
Proof. intros. unfold disjoint in *. simpl_asnlist in *. fsetdec. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
disjoint_app_1
| |
disjoint_app_2 :
forall A B (E F : list (asn A B)) (G : list (asn A B)),
disjoint (E ++ F) G ->
disjoint F G.
Proof. intros. unfold disjoint in *. simpl_asnlist in *. fsetdec. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
disjoint_app_2
| |
disjoint_app_3 :
forall A B (E F : list (asn A B)) (G : list (asn A B)),
disjoint E G ->
disjoint F G ->
disjoint (E ++ F) G.
Proof. intros. unfold disjoint in *. simpl_asnlist in *. fsetdec. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
disjoint_app_3
| |
disjoint_app_l :
forall A B (E F : list (asn A B)) (G : list (asn A B)),
disjoint (E ++ F) G <-> disjoint E G /\ disjoint F G.
Proof.
intros; intuition eauto using
disjoint_app_1, disjoint_app_2, disjoint_app_3.
Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
disjoint_app_l
| |
disjoint_app_r :
forall A B (E F : list (asn A B)) (G : list (asn A B)),
disjoint G (E ++ F) <-> disjoint E G /\ disjoint F G.
Proof. intros. rewrite -> disjoint_sym. apply disjoint_app_l. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
disjoint_app_r
| |
disjoint_map_1 :
forall A B C (E : list (asn A B)) (F : list (asn A B)) (f1 : A -> A) (f2 : B -> B),
disjoint (map f1 f2 E) F ->
disjoint E F.
Proof. unfold disjoint. intros. simpl_asnlist in *. trivial. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
disjoint_map_1
| |
disjoint_map_2 :
forall A B C (E : list (asn A B)) (F : list (asn A B)) (f1 : A -> A)(f2: B -> B),
disjoint E F ->
disjoint (map f1 f2 E) F.
Proof. unfold disjoint. intros. simpl_asnlist in *. trivial. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
disjoint_map_2
| |
disjoint_map_l :
forall A B C (E : list (asn A B)) (F : list (asn A B)) (f1 : A -> A) (f2: B -> B),
disjoint (map f1 f2 E) F <-> disjoint E F.
Proof. intros; intuition eauto using disjoint_map_1, disjoint_map_2. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
disjoint_map_l
| |
disjoint_map_r :
forall A B C (E : list (asn A B)) (F : list (asn A B)) (f1 : A -> A) (f2: B -> B),
disjoint F (map f1 f2 E) <-> disjoint E F.
Proof. intros. rewrite -> disjoint_sym. apply disjoint_map_l. auto. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
disjoint_map_r
| |
UniqProperties .
Variables A B : Set.
Variables f1 : A -> A.
Variables f2 : B -> B.
Variables x : atom.
Variables b : A.
Variables E F G : list (asn A B).
|
Section
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
UniqProperties
| |
uniq_one_1 :
uniq (one (VarAsn B x b)).
Proof.
clear. rewrite_asnlist ((one (VarAsn B x b)) ++ nil).
apply uniq_push; [ apply uniq_nil | fsetdec ].
Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
uniq_one_1
| |
uniq_app_1 :
uniq (E ++ F) -> uniq E.
Proof.
clear. intros H; induction E as [ | a E']; simpl_asnlist in *.
apply uniq_nil.
destruct a.
apply uniq_push; inversion H; subst.
auto.
simpl_asnlist in *. fsetdec.
apply uniq_alt; inversion H; subst.
auto.
Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
uniq_app_1
| |
uniq_app_2 :
uniq (E ++ F) -> uniq F.
Proof.
clear. intros H; induction E as [ | a E'].
apply H.
inversion H; subst. auto.
inversion H; subst. auto.
Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
uniq_app_2
| |
uniq_app_3 :
uniq (E ++ F) -> disjoint E F.
Proof.
clear. intros H. red. induction E as [ | a E'].
fsetdec.
inversion H; subst. simpl_asnlist in *. lapply IHE'.
fsetdec.
assumption.
inversion H; subst. simpl_asnlist in *. lapply IHE'.
fsetdec.
assumption.
Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
uniq_app_3
| |
uniq_app_4 :
uniq E ->
uniq F ->
disjoint E F ->
uniq (E ++ F).
Proof.
clear. intros HE HF Hd.
induction E as [ | a E']; simpl_asnlist in *.
assumption.
rewrite -> disjoint_app_l in Hd.
inversion HE; subst. apply uniq_push.
intuition.
rewrite disjoint_one_l in Hd. simpl_asnlist. fsetdec.
apply uniq_alt.
inversion HE; subst.
intuition.
Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
uniq_app_4
| |
uniq_app :
uniq (E ++ F) <-> uniq E /\ uniq F /\ disjoint E F.
Proof.
clear; intuition eauto using
uniq_app_1, uniq_app_2, uniq_app_3, uniq_app_4.
Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
uniq_app
| |
uniq_map_1 :
uniq (map f1 f2 E) ->
uniq E.
Proof.
clear. intros H. induction E as [ | a E']; simpl_asnlist in *.
apply uniq_nil.
destruct a.
inversion H; subst. apply uniq_push; simpl_asnlist in *; auto.
inversion H; subst. apply uniq_alt; simpl_asnlist in *; auto.
Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
uniq_map_1
| |
uniq_map_2 :
uniq E ->
uniq (map f1 f2 E).
Proof.
clear. intros J. induction E as [ | a E']; simpl_asnlist in *.
apply uniq_nil.
inversion J; subst. simpl_asnlist. apply uniq_push.
auto.
rewrite dom_map. trivial.
inversion J; subst. simpl_asnlist. apply uniq_alt. auto.
Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
uniq_map_2
| |
uniq_map :
uniq (map f1 f2 E) <-> uniq E.
Proof.
clear. intuition eauto using uniq_map_1, uniq_map_2.
Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
uniq_map
| |
solve_uniq :=
try trivial;
simpl_asnlist in *;
autorewrite with rewr_uniq in *;
simpl_asnlist in *;
intuition (
auto using uniq_nil, uniq_one_1 ||
(rewrite -> disjoint_sym; auto) ||
(unfold disjoint in *; fsetdec))
|| fail.
(* ********************************************************************* *)
(** ** Facts about [uniq] *)
|
Ltac
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
solve_uniq
| |
UniqDerived .
Variables A B : Set.
Variables x y : atom.
Variables a b : A.
Variables E F G : list (asn A B).
|
Section
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
UniqDerived
| |
uniq_cons_3 :
uniq E ->
x `notin` dom E ->
uniq ((VarAsn B x a) :: E).
Proof. clear. solve_uniq. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
uniq_cons_3
| |
uniq_insert_mid :
uniq (G ++ E) ->
x `notin` dom (G ++ E) ->
uniq (G ++ (one (VarAsn B x a)) ++ E).
Proof. clear. solve_uniq. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
uniq_insert_mid
| |
uniq_remove_mid :
uniq (E ++ F ++ G) ->
uniq (E ++ G).
Proof. clear. solve_uniq. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
uniq_remove_mid
| |
uniq_map_app_l : forall (f1 : A -> A)(f2: B -> B),
uniq (F ++ E) ->
uniq (map f1 f2 F ++ E).
Proof. clear. intros. solve_uniq. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
uniq_map_app_l
| |
fresh_mid_tail :
uniq (F ++ (one (VarAsn B x a)) ++ E) ->
x `notin` dom E.
Proof. clear. solve_uniq. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
fresh_mid_tail
| |
fresh_mid_head :
uniq (F ++ (one (VarAsn B x a)) ++ E) ->
x `notin` dom F.
Proof. clear. solve_uniq. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
fresh_mid_head
| |
BindsProperties .
Variables A B : Set.
Variables x y : atom.
Variables a b : A.
Variables E F G : list (asn A B).
|
Section
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
BindsProperties
| |
binds_nil :
binds x a (@nil (asn A B)) <-> False.
Proof. clear. split. inversion 1. intuition. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
binds_nil
| |
binds_one_3 :
x = y ->
a = b ->
binds x a (one (VarAsn B y b)).
Proof. clear. intros. red. simpl. left. congruence. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
binds_one_3
| |
binds_one_1 :
binds x a (one (VarAsn B y b)) ->
x = y.
Proof.
clear. intros H1. inversion H1 as [HEq | HIn].
inversion HEq; intuition.
intuition.
Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
binds_one_1
| |
binds_one_2 :
binds x a (one (VarAsn B y b)) ->
a = b.
Proof.
clear. intros H1. inversion H1 as [HEq | HIn].
inversion HEq; intuition.
intuition.
Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
binds_one_2
| |
binds_one_iff :
binds x a (one (VarAsn B y b)) <-> x = y /\ a = b.
Proof.
clear. split.
intros H1. intuition eauto using binds_one_1, binds_one_2.
intros H1. intuition auto using binds_one_3.
Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
binds_one_iff
| |
binds_cons_1 :
binds x a ((VarAsn B y b) :: E) ->
(x = y /\ a = b) \/ binds x a E.
Proof. clear. inversion 1 as [J | J]; try injection J; auto. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
binds_cons_1
| |
binds_cons_2 :
x = y ->
a = b ->
binds x a ((VarAsn B y b) :: E).
Proof. clear. unfold binds. simpl. left. f_equal; auto. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
binds_cons_2
| |
binds_cons_3 :
binds x a E ->
binds x a ((VarAsn B y b) :: E).
Proof. clear. unfold binds. simpl. right. trivial. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
binds_cons_3
| |
binds_cons_iff :
binds x a ((VarAsn B y b) :: E) <-> (x = y /\ a = b) \/ binds x a E.
Proof.
clear. intuition auto using binds_cons_1, binds_cons_2, binds_cons_3.
Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
binds_cons_iff
| |
binds_app_1 :
binds x a E ->
binds x a (E ++ F).
Proof. clear. intros H. red in H |- *. rewrite -> in_app. auto. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
binds_app_1
| |
binds_app_2 :
binds x a F ->
binds x a (E ++ F).
Proof. clear. intros H. red in H |- *. rewrite -> in_app. auto. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
binds_app_2
| |
binds_app_3 :
binds x a (E ++ F) ->
binds x a E \/ binds x a F.
Proof.
clear. induction E as [ | a1 E' ].
auto.
unfold binds. simpl. intros [H | H].
inversion H; subst. auto.
unfold binds in *. apply IHE' in H. intuition.
Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
binds_app_3
| |
binds_app :
binds x a (E ++ F) <-> binds x a E \/ binds x a F.
Proof.
clear. intuition auto using binds_app_1, binds_app_2, binds_app_3.
Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
binds_app
| |
MoreBindsProperties .
Variables A B : Set.
Variables x y : atom.
Variables a b : A.
Variables E F G : list (asn A B).
|
Section
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
MoreBindsProperties
| |
binds_dom_contradiction : forall (E : list (asn A B)),
binds x a E ->
x `notin` dom E ->
False.
Proof.
clear. induction E as [ | a1 E' ]; simpl.
intros H. inversion H.
unfold binds in *. simpl. intros [H | H] J.
inversion H; subst. fsetdec.
apply IHE' in H. trivial. destruct a1. fsetdec. auto.
Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
binds_dom_contradiction
| |
binds_app_uniq :
uniq (E ++ F) ->
(binds x a (E ++ F) <->
(binds x a E /\ x `notin` dom F) \/
(binds x a F /\ x `notin` dom E)).
Proof with intuition (fsetdec || eauto using binds_dom_contradiction).
clear. intros H1.
autorewrite with rewr_uniq in H1. unfold disjoint in H1.
assert (H : x `notin` dom F \/ x `notin` dom E) by fsetdec.
rewrite binds_app...
Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
binds_app_uniq
| |
apply_binds_dom_contradiction :=
match goal with
| H : binds ?x ?a ?E, J : ?x `notin` (dom ?E) |- _ =>
assert False by apply (@binds_dom_contradiction _ _ _ _ H J);
intuition
| H : binds ?x ?a ?E, J : ?x `in` (dom ?E) -> False |- _ =>
assert False by apply (@binds_dom_contradiction _ _ _ _ H J);
intuition
end.
(** The [solve_binds] tactic attempts to solve goals about [binds].
Given its definition, it's likely to work only when the
hypotheses in the goal already contain all the relevant [binds]
propositions. Thus, the tactic may not be generally useful. It
is useful, however, for proving facts about [binds] such as the
ones below. *)
|
Ltac
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
apply_binds_dom_contradiction
| |
solve_binds :=
simpl_asnlist in *;
autorewrite with rewr_binds in *;
intuition (auto || fsetdec || apply_binds_dom_contradiction)
|| fail.
(** The tactics [analyze_binds] and [analyze_binds_uniq] tactics
take as an argument a hypotheses about [binds] and perform a
case analysis based on the structure of the association list.
In the case of [analyze_binds_uniq], the analysis is performed
assuming that the association list is [uniq]. The lemmas
[binds_app] and [binds_app_uniq] are examples of such case
analysis.
Implementation notes:
- The initial calls to [simpl_asnlist] put the relevant
association lists into normal form.
- In the case of [binds_app_uniq], we assert that the
association list is [uniq]. This enables the [autorewrite]
step to succeed.
- Rather than work on [H] itself, we copy it and work on the
copy. Thus, in instances where the analysis leaves unsolved
subgoals, it is still possible to see the original
hypothesis.
- The rest of the tactic breaks apart the copy of H and tries
several simple means for solving the resulting subgoals. *)
|
Ltac
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
solve_binds
| |
analyze_binds H :=
simpl_asnlist;
simpl_asnlist in H;
match type of H with
| binds ?x ?a ?E =>
let J := fresh in
pose proof H as J;
autorewrite with rewr_binds in J;
simpl_asnlist in J;
try (progress decompose [and or] J; clear J);
try solve [trivial | discriminate | intuition | fsetdec]
end.
|
Ltac
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
analyze_binds
| |
analyze_binds_uniq H :=
simpl_asnlist;
simpl_asnlist in H;
match type of H with
| binds ?x ?a ?E =>
match goal with
| H : uniq ?E |- _ => idtac
| _ => assert (uniq E); [ try solve_uniq | ]
end;
let J := fresh in
pose proof H as J;
autorewrite with rewr_binds_uniq in J;
simpl_asnlist in J;
try (progress decompose [and or] J; clear J);
try solve [trivial | discriminate | intuition | fsetdec]
end.
(* ********************************************************************* *)
(** ** Facts about [binds] *)
|
Ltac
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
analyze_binds_uniq
| |
BindsDerived .
Variables A B : Set.
Variables f1 : A -> A.
Variables f2 : B -> B.
Variables x y : atom.
Variables a b : A.
Variables E F G : list (asn A B).
|
Section
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
BindsDerived
| |
binds_map_2 :
binds x a E ->
binds x (f1 a) (map f1 f2 E).
Proof.
clear. induction E; simpl_asnlist.
inversion 1.
unfold binds in *. simpl. intros [? | ?].
destruct a0.
inversion H; subst.
left. congruence.
inversion H.
destruct a0.
right. auto.
right. auto.
Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
binds_map_2
| |
binds_weaken :
binds x a (E ++ G) ->
binds x a (E ++ F ++ G).
Proof. clear. intros. solve_binds. Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
binds_weaken
| |
binds_In : forall x a (E : list (asn A B)),
binds x a E ->
x `in` dom E.
Proof.
clear. induction E as [ | y ? F ]; intros J; simpl_asnlist.
analyze_binds J.
analyze_binds J; subst; auto with set.
inversion H0;subst. simpl. fsetdec.
inversion H.
Qed.
|
Lemma
|
Attic
|
[
"Require Import Coq.",
"Require Import Metalib."
] |
Attic/AssumeList.v
|
binds_In
|
End of preview. Expand
in Data Studio
Coq-Metalib
Structured declarations from Metalib - a Coq library for programming language metatheory using locally nameless representation. Source: github.com/plclub/metalib
Schema
| Column | Type | Description |
|---|---|---|
fact |
string | Declaration body (without type keyword) |
type |
string | Declaration type (Lemma, Definition, etc.) |
library |
string | Source module |
imports |
list | Import statements |
filename |
string | Source file path |
symbolic_name |
string | Declaration identifier |
Statistics
- Total entries: 1748
- Unique files: 33
- Declaration types: Axiom, Class, Coercion, Definition, Fixpoint, Inductive, Lemma, Local Notation, Ltac, Module, Notation, Parameter, Section, Tactic, Theorem
Usage
from datasets import load_dataset
ds = load_dataset("phanerozoic/Coq-Metalib")
License
mit
- Downloads last month
- 22
Size of downloaded dataset files:
211 kB
Size of the auto-converted Parquet files:
211 kB
Number of rows:
1,748