Dataset Viewer
Auto-converted to Parquet Duplicate
statement
stringlengths
1
395
proof
stringlengths
0
6.32k
type
stringclasses
15 values
symbolic_name
stringlengths
1
59
library
stringclasses
5 values
filename
stringclasses
33 values
imports
listlengths
1
13
deps
listlengths
0
24
docstring
stringlengths
0
2.36k
source_url
stringclasses
1 value
commit
stringclasses
1 value
one (C : Set) (item : C) : list C
:= cons item nil.
Definition
one
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
asn (A:Set) (B:Set) : Set
:= | VarAsn : atom -> A -> asn A B | AltAsn : B -> asn A B .
Inductive
asn
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "atom" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
map
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "asn" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
dom
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "add", "asn", "atoms", "empty" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
disjoint (E : list (asn A B)) (F : list (asn A B)) : Prop
:= Subset (inter (dom E) (dom F)) empty.
Definition
disjoint
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "Subset", "asn", "dom", "empty", "inter" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
binds (x : atom) (a : A) (E : list (asn A B)) : Prop
:= List.In (VarAsn B x a) E.
Definition
binds
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "In", "asn", "atom" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
bindsAlt (b : B) (E : list (asn A B)) : Prop
:= List.In (AltAsn A b) E.
Definition
bindsAlt
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "In", "asn" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
"x ~~ a"
:= (one (VarAsn B x a)) (at level 68).
Notation
x ~~ a
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "one" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
"x `notin` E"
:= (~ In x E) (at level 70).
Notation
x `notin` E
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "In" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
uniq
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "asn", "dom", "notin", "one" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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.
Fixpoint
erase
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "asn" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
"[ i ]"
:= (one i).
Notation
[ i ]
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "one" ]
We make a local notation for [one], and for operations and predicate on finite sets, in order to make the statements of the lemmas below more readable. The notations are local so that users of this functor may choose their own notations.
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
"E `union` F"
:= (union E F) (at level 65, right associativity).
Notation
E `union` F
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "union" ]
Local Notation "x ~~ T" := (one (VarAsn B x T)) (at level 68).
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
"x `in` E"
:= (In x E) (at level 70).
Notation
x `in` E
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "In" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
"x `notin` E"
:= (~ In x E) (at level 70).
Notation
x `notin` E
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "In" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
"E [=] F"
:= (Equal E F) (at level 70, no associativity).
Notation
E [=] F
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "Equal" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
"E [<=] F"
:= (Subset E F) (at level 70, no associativity).
Notation
E [<=] F
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "Subset" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
cons_app_one : cons x l = [ x ] ++ l.
Proof. clear. reflexivity. Qed.
Lemma
cons_app_one
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
cons_app_assoc : (cons x l1) ++ l2 = cons x (l1 ++ l2).
Proof. clear. reflexivity. Qed.
Lemma
cons_app_assoc
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
app_assoc : (l1 ++ l2) ++ l3 = l1 ++ (l2 ++ l3).
Proof. clear. apply app_ass. Qed.
Lemma
app_assoc
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
app_nil_1 : nil ++ l = l.
Proof. clear. reflexivity. Qed.
Lemma
app_nil_1
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
app_nil_2 : l ++ nil = l.
Proof. clear. auto with datatypes. Qed.
Lemma
app_nil_2
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
in_one : List.In x [ y ] <-> x = y.
Proof. clear. simpl. intuition congruence. Qed.
Lemma
in_one
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "In" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
in_app
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "In" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
one_eq_app
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "cons_eq_app" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
app_eq_one
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "app_eq_cons" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
nil_neq_one_mid : nil <> l1 ++ [ x ] ++ l2.
Proof. simpl. apply List.app_cons_not_nil. Qed.
Lemma
nil_neq_one_mid
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "app_cons_not_nil" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
one_mid_neq_nil
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "app_cons_not_nil" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
map_nil : map f1 f2 nil = nil.
Proof. clear. reflexivity. Qed.
Lemma
map_nil
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "map" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
map_consVar : map f1 f2 ((VarAsn B x b) :: E) = (VarAsn B x (f1 b)) :: map f1 f2 E.
Proof. clear. reflexivity. Qed.
Lemma
map_consVar
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "map" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
map_consAlt : map f1 f2 ((AltAsn A a) :: E) = (AltAsn A (f2 a)) :: map f1 f2 E.
Proof. clear. reflexivity. Qed.
Lemma
map_consAlt
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "map" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
map_oneVar : map f1 f2 (one (VarAsn B x b)) = one (VarAsn B x (f1 b)).
Proof. clear. reflexivity. Qed.
Lemma
map_oneVar
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "map", "one" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
map_oneAlt : map f1 f2 (one (AltAsn A a)) = one (AltAsn A (f2 a)).
Proof. clear. reflexivity. Qed.
Lemma
map_oneAlt
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "map", "one" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
map_app
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "map" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
dom_nil : (@dom A B nil) = empty.
Proof. clear. reflexivity. Qed.
Lemma
dom_nil
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "dom", "empty" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
dom_consVar : dom (VarAsn B x b :: E) [=] singleton x `union` dom E.
Proof. clear. simpl. fsetdec. Qed.
Lemma
dom_consVar
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "dom", "fsetdec", "singleton", "union" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
dom_consAlt : dom (AltAsn A a :: E) [=] dom E.
Proof. clear. simpl. fsetdec. Qed.
Lemma
dom_consAlt
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "dom", "fsetdec" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
dom_one : dom (one (VarAsn B x b)) [=] singleton x.
Proof. clear. simpl. fsetdec. Qed.
Lemma
dom_one
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "dom", "fsetdec", "one", "singleton" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
dom_app : dom (E ++ F) [=] dom E `union` dom F.
Proof. clear. induction E as [ | a ]; simpl; try (destruct a); fsetdec. Qed.
Lemma
dom_app
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "dom", "fsetdec", "union" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
dom_map : dom (map f1 f2 E) [=] dom E.
Proof. clear. induction E as [ | a ]; simpl; try (destruct a); fsetdec. Qed.
Lemma
dom_map
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "dom", "fsetdec", "map" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
simpl_asnlist
:= autorewrite with rewr_list rewr_list_in rewr_map rewr_dom.
Ltac
simpl_asnlist
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[]
The [simpl_alist] tactic rewrites association lists so that they are in the normal form described above. Similar to the [simpl] tactic, we define "[in *]" and "[in H]" variants of the tactic.
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
disjoint_sym_1
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "asn", "disjoint", "fsetdec" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
disjoint_sym
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "asn", "disjoint", "disjoint_sym_1" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
disjoint_one_1
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "asn", "atom", "disjoint", "dom", "fsetdec", "notin", "one", "simpl_asnlist" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
disjoint_one_2
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "asn", "atom", "disjoint", "dom", "fsetdec", "notin", "one", "simpl_asnlist" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
disjoint_one_l
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "asn", "atom", "disjoint", "dom", "fsetdec", "notin", "one", "simpl_asnlist" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
disjoint_one_r
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "asn", "atom", "disjoint", "disjoint_one_l", "disjoint_sym", "dom", "notin", "one" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
disjoint_app_1
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "asn", "disjoint", "fsetdec", "simpl_asnlist" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
disjoint_app_2
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "asn", "disjoint", "fsetdec", "simpl_asnlist" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
disjoint_app_3
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "asn", "disjoint", "fsetdec", "simpl_asnlist" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
disjoint_app_l
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "asn", "disjoint", "disjoint_app_1", "disjoint_app_2", "disjoint_app_3" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
disjoint_app_r
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "asn", "disjoint", "disjoint_app_l", "disjoint_sym" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
disjoint_map_1
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "asn", "disjoint", "map", "simpl_asnlist" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
disjoint_map_2
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "asn", "disjoint", "map", "simpl_asnlist" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
disjoint_map_l
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "asn", "disjoint", "disjoint_map_1", "disjoint_map_2", "map" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
disjoint_map_r
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "asn", "disjoint", "disjoint_map_l", "disjoint_sym", "map" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
uniq_one_1
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "fsetdec", "one", "uniq" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
uniq_app_1
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "fsetdec", "simpl_asnlist", "subst", "uniq" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
uniq_app_2
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "subst", "uniq" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
uniq_app_3
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "disjoint", "fsetdec", "red", "simpl_asnlist", "subst", "uniq" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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. ...
Lemma
uniq_app_4
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "disjoint", "disjoint_app_l", "disjoint_one_l", "fsetdec", "simpl_asnlist", "subst", "uniq" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
uniq_app
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "disjoint", "uniq", "uniq_app_1", "uniq_app_2", "uniq_app_3", "uniq_app_4" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
uniq_map_1
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "map", "simpl_asnlist", "subst", "uniq" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
uniq_map_2
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "dom_map", "map", "simpl_asnlist", "subst", "uniq" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
uniq_map : uniq (map f1 f2 E) <-> uniq E.
Proof. clear. intuition eauto using uniq_map_1, uniq_map_2. Qed.
Lemma
uniq_map
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "map", "uniq", "uniq_map_1", "uniq_map_2" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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.
Ltac
solve_uniq
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "disjoint", "disjoint_sym", "fsetdec", "simpl_asnlist", "uniq_one_1" ]
This tactic attempts to solve goals about [uniq]. Given its definition, it's likely to work only when the hypotheses in the goal already contain all the relevant [uniq] propositions. Thus, the tactic may not be generally useful. It is useful, however, for proving facts about [uniq] such as the...
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
uniq_cons_3 : uniq E -> x `notin` dom E -> uniq ((VarAsn B x a) :: E).
Proof. clear. solve_uniq. Qed.
Lemma
uniq_cons_3
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "dom", "notin", "solve_uniq", "uniq" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
uniq_insert_mid
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "dom", "notin", "one", "solve_uniq", "uniq" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
uniq_remove_mid : uniq (E ++ F ++ G) -> uniq (E ++ G).
Proof. clear. solve_uniq. Qed.
Lemma
uniq_remove_mid
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "solve_uniq", "uniq" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
uniq_map_app_l
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "map", "solve_uniq", "uniq" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
fresh_mid_tail : uniq (F ++ (one (VarAsn B x a)) ++ E) -> x `notin` dom E.
Proof. clear. solve_uniq. Qed.
Lemma
fresh_mid_tail
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "dom", "notin", "one", "solve_uniq", "uniq" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
fresh_mid_head : uniq (F ++ (one (VarAsn B x a)) ++ E) -> x `notin` dom F.
Proof. clear. solve_uniq. Qed.
Lemma
fresh_mid_head
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "dom", "notin", "one", "solve_uniq", "uniq" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
binds_nil : binds x a (@nil (asn A B)) <-> False.
Proof. clear. split. inversion 1. intuition. Qed.
Lemma
binds_nil
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "asn", "binds" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
binds_one_3 : x = y -> a = b -> binds x a (one (VarAsn B y b)).
Proof. clear. intros. red. simpl. left. congruence. Qed.
Lemma
binds_one_3
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "binds", "one", "red" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
binds_one_1
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "binds", "one" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
binds_one_2
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "binds", "one" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
binds_one_iff
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "binds", "binds_one_1", "binds_one_2", "binds_one_3", "one" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
binds_cons_1
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "binds" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
binds_cons_2
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "binds" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
binds_cons_3 : binds x a E -> binds x a ((VarAsn B y b) :: E).
Proof. clear. unfold binds. simpl. right. trivial. Qed.
Lemma
binds_cons_3
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "binds" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
binds_cons_iff
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "binds", "binds_cons_1", "binds_cons_2", "binds_cons_3" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
binds_app_1
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "binds", "in_app", "red" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
binds_app_2
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "binds", "in_app", "red" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
binds_app_3
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "binds", "subst" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
binds_app
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "binds", "binds_app_1", "binds_app_2", "binds_app_3" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
binds_dom_contradiction
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "asn", "binds", "dom", "fsetdec", "notin", "subst" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
binds_app_uniq
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "binds", "binds_app", "binds_dom_contradiction", "disjoint", "dom", "fsetdec", "notin", "uniq" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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); intui...
Ltac
apply_binds_dom_contradiction
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "binds", "binds_dom_contradiction", "dom", "notin" ]
The [apply_binds_dom_contradiction] tactic solves a goal by applying the [binds_dom_contradiction] lemma. The tactic succeeds only if the the hypotheses of the lemma are immediately satisfied.
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
solve_binds
:= simpl_asnlist in *; autorewrite with rewr_binds in *; intuition (auto || fsetdec || apply_binds_dom_contradiction) || fail.
Ltac
solve_binds
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "apply_binds_dom_contradiction", "fsetdec", "simpl_asnlist" ]
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 [bi...
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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 | in...
Ltac
analyze_binds
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "binds", "fresh", "fsetdec", "progress", "simpl_asnlist", "type" ]
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]. Th...
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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...
Ltac
analyze_binds_uniq
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "binds", "fresh", "fsetdec", "progress", "simpl_asnlist", "solve_uniq", "type", "uniq" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
binds_map_2
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "binds", "map", "simpl_asnlist", "subst" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
binds_weaken : binds x a (E ++ G) -> binds x a (E ++ F ++ G).
Proof. clear. intros. solve_binds. Qed.
Lemma
binds_weaken
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "binds", "solve_binds" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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
binds_In
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "analyze_binds", "asn", "binds", "dom", "fsetdec", "simpl_asnlist", "subst" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
fresh_app_l : uniq (F ++ E) -> binds x a E -> x `notin` dom F.
Proof. clear. intros. assert (x `in` dom E) by eauto using binds_In. solve_uniq. Qed.
Lemma
fresh_app_l
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "binds", "binds_In", "dom", "notin", "solve_uniq", "uniq" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
fresh_app_r : uniq (F ++ E) -> binds x a F -> x `notin` dom E.
Proof. clear. intros. assert (x `in` dom F) by eauto using binds_In. solve_uniq. Qed.
Lemma
fresh_app_r
Attic
Attic/AssumeList.v
[ "Coq.FSets.FSets", "Coq.Lists.List", "Coq.Logic.Decidable", "Metalib.CoqFSetDecide", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "AtomSetImpl" ]
[ "binds", "binds_In", "dom", "notin", "solve_uniq", "uniq" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
" x == y "
:= (eq_dec x y) (at level 70) : coqeqdec_scope.
Notation
x == y
Attic
Attic/MetatheoryAlt.v
[ "Coq.Arith.Arith", "Coq.FSets.FSets", "Coq.Lists.List", "Metalib.CoqEqDec", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "Metalib.AssumeList" ]
[ "eq_dec" ]
We prefer that "==" refer to decidable equality at [eq], as defined by the [EqDec_eq] class from the CoqEqDec library.
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
"E [=] F"
:= (AtomSetImpl.Equal E F) (at level 70, no associativity) : set_scope.
Notation
E [=] F
Attic
Attic/MetatheoryAlt.v
[ "Coq.Arith.Arith", "Coq.FSets.FSets", "Coq.Lists.List", "Metalib.CoqEqDec", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "Metalib.AssumeList" ]
[ "Equal" ]
Common set operations and constants may be written using more convenient notations.
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
"E [<=] F"
:= (AtomSetImpl.Subset E F) (at level 70, no associativity) : set_scope.
Notation
E [<=] F
Attic
Attic/MetatheoryAlt.v
[ "Coq.Arith.Arith", "Coq.FSets.FSets", "Coq.Lists.List", "Metalib.CoqEqDec", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "Metalib.AssumeList" ]
[ "Subset" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
"{}"
:= (AtomSetImpl.empty) : set_scope.
Notation
{}
Attic
Attic/MetatheoryAlt.v
[ "Coq.Arith.Arith", "Coq.FSets.FSets", "Coq.Lists.List", "Metalib.CoqEqDec", "Metalib.CoqListFacts", "Metalib.LibTactics", "Metalib.MetatheoryAtom", "Metalib.AssumeList" ]
[ "empty" ]
https://github.com/plclub/metalib
144ddcd0fff6717229140314cf559d85fad6eae0
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

Source

Schema

Column Type Description
statement string Declaration signature/claim with the leading keyword removed (verbatim slice); the full declaration minus its proof
proof string Verbatim proof/body, empty if the declaration has none
type string Declaration keyword
symbolic_name string Declaration identifier
library string Sub-library
filename string Repository-relative source path
imports list[string] File-level Require/Import modules
deps list[string] Intra-corpus identifiers referenced
docstring string Preceding documentation comment, empty if absent
source_url string Upstream repository
commit string Upstream commit extracted

Statistics

  • Entries: 1,259
  • With proof: 1,031 (81.9%)
  • With docstring: 559 (44.4%)
  • Libraries: 5

By type

Type Count
Lemma 646
Parameter 121
Axiom 94
Ltac 92
Definition 90
Notation 69
Inductive 55
Fixpoint 47
Scheme 13
Theorem 7
Hypothesis 7
Example 7
Coercion 6
Instance 4
Class 1

Example

asn (A:Set) (B:Set) : Set
:=
      | VarAsn : atom -> A -> asn A B
      | AltAsn : B         -> asn A B
    .
  • type: Inductive | symbolic_name: asn | Attic/AssumeList.v

Use

Each declaration is split into a statement (signature/claim) and a proof (body) that are disjoint and together form the complete declaration, for proof modeling, autoformalization, retrieval, and dependency analysis via deps.

Citation

@misc{coq_metalib_dataset,
  title  = {Coq-Metalib},
  author = {Norton, Charles},
  year   = {2026},
  note   = {Extracted from https://github.com/plclub/metalib, commit 144ddcd0fff6},
  url    = {https://huggingface.co/datasets/phanerozoic/Coq-Metalib}
}
Downloads last month
24

Collection including phanerozoic/Coq-Metalib