(* Specifications: *)
Lemma cons_eq_app : forall (A : Type) (z : A) (xs ys zs : list A), z :: zs = xs ++ ys -> (exists qs, xs = z :: qs /\ zs = qs ++ ys) \/ (xs = nil /\ ys = z :: zs).
Lemma app_eq_cons : forall (A : Type) (z : A) (xs ys zs : list A), xs ++ ys = z :: zs -> (exists qs, xs = z :: qs /\ zs = qs ++ ys) \/ (xs = nil /\ ys = z :: zs).
Lemma nil_eq_app : forall (A : Type) (xs ys : list A), nil = xs ++ ys -> xs = nil /\ ys = nil.
Lemma app_cons_not_nil : forall (A : Type) (y : A) (xs ys : list A), xs ++ y :: ys <> nil.
Lemma In_map : forall (A B : Type) (xs : list A) (x : A) (f : A -> B), In x xs -> In (f x) (map f xs).
Lemma not_In_cons : forall (A : Type) (ys : list A) (x y : A), x <> y -> ~ In x ys -> ~ In x (y :: ys).
Lemma not_In_app : forall (A : Type) (xs ys : list A) (x : A), ~ In x xs -> ~ In x ys -> ~ In x (xs ++ ys).
Lemma elim_not_In_cons : forall (A : Type) (y : A) (ys : list A) (x : A), ~ In x (y :: ys) -> x <> y /\ ~ In x ys.
Lemma elim_not_In_app : forall (A : Type) (xs ys : list A) (x : A), ~ In x (xs ++ ys) -> ~ In x xs /\ ~ In x ys.
Lemma incl_nil : forall (A : Type) (xs : list A), incl nil xs.
Lemma In_incl : forall (A : Type) (x : A) (ys zs : list A), In x ys -> incl ys zs -> In x zs.
Lemma elim_incl_cons : forall (A : Type) (x : A) (xs zs : list A), incl (x :: xs) zs -> In x zs /\ incl xs zs.
Lemma elim_incl_app : forall (A : Type) (xs ys zs : list A), incl (xs ++ ys) zs -> incl xs zs /\ incl ys zs.
Lemma InA_In : forall (A : Type) (x : A) (xs : list A), InA (@eq _) x xs -> In x xs.
Lemma InA_iff_In : forall (A : Type) (x : A) (xs : list A), InA (@eq _) x xs <-> In x xs.
Theorem lelistA_dec : forall a xs, {lelistA leA a xs} + {~ lelistA leA a xs}.
Theorem sort_dec : forall xs, {sort leA xs} + {~ sort leA xs}.
Lemma sub_reflexivity : forall E T, wf_env E -> wf_typ E T -> sub E T T.
Lemma sub_weakening : forall E F G S T, sub (G ++ E) S T -> wf_env (G ++ F ++ E) -> sub (G ++ F ++ E) S T.
Lemma type_from_wf_typ : forall E T, wf_typ E T -> type T.
Lemma wf_typ_weakening : forall T E F G, wf_typ (G ++ E) T -> uniq (G ++ F ++ E) -> wf_typ (G ++ F ++ E) T.
Lemma wf_typ_weaken_head : forall T E F, wf_typ E T -> uniq (F ++ E) -> wf_typ (F ++ E) T.
Lemma wf_typ_open : forall E U T1 T2, uniq E -> wf_typ E (typ_all T1 T2) -> wf_typ E U -> wf_typ E (open_tt T2 U).
Lemma uniq_from_wf_env : forall E, wf_env E -> uniq E.
Lemma wf_typ_from_binds_typ : forall x U E, wf_env E -> binds x (bind_typ U) E -> wf_typ E U.
Lemma sub_regular : forall E S T, sub E S T -> wf_env E /\ wf_typ E S /\ wf_typ E T.
Lemma typing_regular : forall E e T, typing E e T -> wf_env E /\ expr e /\ wf_typ E T.
Lemma value_regular : forall e, value e -> expr e.
Lemma red_regular : forall e e', red e e' -> expr e /\ expr e'.
Lemma append_assoc_demo : forall (E0 E1 E2 E3:ctx), E0 ++ (E1 ++ E2) ++ E3 = E0 ++ E1 ++ E2 ++ E3.
Lemma typing_weakening_0 : forall E F e T, typing_e E e T -> uniq (F ++ E) -> typing_e (F ++ E) e T.
Lemma typing_weakening_strengthened_0 : forall (E F G : ctx) e T, typing_e (G ++ E) e T -> uniq (G ++ F ++ E) -> typing_e (G ++ F ++ E) e T.
Lemma typing_weakening_strengthened_1 : forall (E F G : ctx) e T, typing_e (G ++ E) e T -> uniq (G ++ F ++ E) -> typing_e (G ++ F ++ E) e T.
Lemma typing_weakening_strengthened : forall (E F G : ctx) e T, typing (G ++ E) e T -> uniq (G ++ F ++ E) -> typing (G ++ F ++ E) e T.
Lemma typing_weakening : forall (E F : ctx) e T, typing E e T -> uniq (F ++ E) -> typing (F ++ E) e T.
Lemma preservation : forall (E : ctx) e e' T, typing E e T -> step e e' -> typing E e' T.
Lemma progress : forall e T, typing nil e T -> is_value e \/ exists e', step e e'.
Lemma typing_uniq : forall E e T, typing E e T -> uniq E.
Lemma exists_cofinite : forall E e T, typing_e E e T -> typing E e T.
Lemma cofinite_exists : forall G e T, typing G e T -> typing_e G e T.