fact stringlengths 6 2.88k | type stringclasses 17
values | library stringclasses 2
values | imports listlengths 0 16 | filename stringclasses 89
values | symbolic_name stringlengths 1 36 | docstring stringclasses 1
value |
|---|---|---|---|---|---|---|
sumor(A:Type) (B:Prop) : Type :=
| inleft : A -> A + {B}
| inright : B -> A + {B}
where "A + { B }" := (sumor A B) : type_scope.
Add Printing If sumor.
Arguments inleft {A B} _ , [A] B _.
Arguments inright {A B} _ , A [B] _. | Inductive | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Datatypes",
"Require Import Logic"
] | Corelib/Init/Specif.v | sumor | |
Choice:
(forall x:S, {y:S' | R x y}) -> {f:S -> S' | forall z:S, R z (f z)}.
Proof.
intro H.
exists (fun z => proj1_sig (H z)).
intro z; destruct (H z); assumption.
Defined. | Lemma | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Datatypes",
"Require Import Logic"
] | Corelib/Init/Specif.v | Choice | |
Choice2:
(forall x:S, {y:S' & R' x y}) -> {f:S -> S' & forall z:S, R' z (f z)}.
Proof.
intro H.
exists (fun z => projT1 (H z)).
intro z; destruct (H z); assumption.
Defined. | Lemma | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Datatypes",
"Require Import Logic"
] | Corelib/Init/Specif.v | Choice2 | |
bool_choice:
(forall x:S, {R1 x} + {R2 x}) ->
{f:S -> bool | forall x:S, f x = true /\ R1 x \/ f x = false /\ R2 x}.
Proof.
intro H.
exists (fun z:S => if H z then true else false).
intro z; destruct (H z); auto.
Defined. | Lemma | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Datatypes",
"Require Import Logic"
] | Corelib/Init/Specif.v | bool_choice | |
dependent_choice:
(forall x:X, {y | R x y}) ->
forall x0, {f : nat -> X | f O = x0 /\ forall n, R (f n) (f (S n))}.
Proof.
intros H x0.
set (f:=fix f n := match n with O => x0 | S n' => proj1_sig (H (f n')) end).
exists f.
split.
- reflexivity.
- intro n; induction n; simpl; apply proj... | Lemma | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Datatypes",
"Require Import Logic"
] | Corelib/Init/Specif.v | dependent_choice | |
Exc:= option A. | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Datatypes",
"Require Import Logic"
] | Corelib/Init/Specif.v | Exc | |
value:= @Some A. | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Datatypes",
"Require Import Logic"
] | Corelib/Init/Specif.v | value | |
error:= @None A. | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Datatypes",
"Require Import Logic"
] | Corelib/Init/Specif.v | error | |
except:= False_rec. (* for compatibility with previous versions *)
Arguments except [P] _. | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Datatypes",
"Require Import Logic"
] | Corelib/Init/Specif.v | except | |
absurd_set: forall (A:Prop) (C:Set), A -> ~ A -> C.
Proof.
intros A C h1 h2.
apply False_rec.
apply (h2 h1).
Defined.
#[global]
Hint Resolve left right inleft inright: core.
#[global]
Hint Resolve exist exist2 existT existT2: core. | Theorem | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Datatypes",
"Require Import Logic"
] | Corelib/Init/Specif.v | absurd_set | |
sumbool_of_bool(b : bool) : {b = true} + {b = false} :=
if b return {b = true} + {b = false} then left eq_refl else right eq_refl.
#[global]
Hint Resolve sumbool_of_bool: bool. | Definition | Corelib | [
"Require Import Logic Datatypes Specif"
] | Corelib/Init/Sumbool.v | sumbool_of_bool | |
bool_eq_rec:
forall (b:bool) (P:bool -> Set),
(b = true -> P true) -> (b = false -> P false) -> P b :=
fun b =>
if b return forall P, (b = true -> P true) -> (b = false -> P false) -> P b
then fun _ H _ => H eq_refl else fun _ _ H => H eq_refl. | Definition | Corelib | [
"Require Import Logic Datatypes Specif"
] | Corelib/Init/Sumbool.v | bool_eq_rec | |
bool_eq_ind:
forall (b:bool) (P:bool -> Prop),
(b = true -> P true) -> (b = false -> P false) -> P b :=
fun b =>
if b return forall P, (b = true -> P true) -> (b = false -> P false) -> P b
then fun _ H _ => H eq_refl else fun _ _ H => H eq_refl. | Definition | Corelib | [
"Require Import Logic Datatypes Specif"
] | Corelib/Init/Sumbool.v | bool_eq_ind | |
sumbool_and: {A /\ C} + {B \/ D} :=
match H1, H2 with
| left a, left c => left (conj a c)
| left a, right d => right (or_intror d)
| right b, left c => right (or_introl b)
| right b, right d => right (or_intror d)
end. | Definition | Corelib | [
"Require Import Logic Datatypes Specif"
] | Corelib/Init/Sumbool.v | sumbool_and | |
sumbool_or: {A \/ C} + {B /\ D} :=
match H1, H2 with
| left a, left c => left (or_intror c)
| left a, right d => left (or_introl a)
| right b, left c => left (or_intror c)
| right b, right d => right (conj b d)
end. | Definition | Corelib | [
"Require Import Logic Datatypes Specif"
] | Corelib/Init/Sumbool.v | sumbool_or | |
sumbool_not: {B} + {A} :=
match H1 with
| left a => right a
| right b => left b
end. | Definition | Corelib | [
"Require Import Logic Datatypes Specif"
] | Corelib/Init/Sumbool.v | sumbool_not | |
bool_of_sumbool(A B : Prop) :
{A} + {B} -> {b : bool | if b then A else B} :=
sumbool_rec _ (exist _ true) (exist _ false).
Arguments bool_of_sumbool : default implicits. | Definition | Corelib | [
"Require Import Logic Datatypes Specif"
] | Corelib/Init/Sumbool.v | bool_of_sumbool | |
exfalso:= Corelib.Init.Ltac.exfalso. | Ltac | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Specif"
] | Corelib/Init/Tactics.v | exfalso | |
contradictH :=
let save tac H := let x:=fresh in intro x; tac H; rename x into H
in
let negpos H := case H; clear H
in
let negneg H := save negpos H
in
let pospos H :=
let A := type of H in (exfalso; revert H; try fold (~A))
in
let posneg H := save pospos H
in
let neg H := match goal with
|... | Ltac | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Specif"
] | Corelib/Init/Tactics.v | contradict | |
false_hypH G :=
let T := type of H in absurd T; [ apply G | assumption ]. | Ltac | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Specif"
] | Corelib/Init/Tactics.v | false_hyp | |
case_eqx := generalize (eq_refl x); pattern x at -1; case x. | Ltac | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Specif"
] | Corelib/Init/Tactics.v | case_eq | |
destr_eqH := discriminate H || (try (injection H as [= H])). | Ltac | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Specif"
] | Corelib/Init/Tactics.v | destr_eq | |
destruct_allt :=
match goal with
| x : t |- _ => destruct x; destruct_all t
| _ => idtac
end. | Ltac | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Specif"
] | Corelib/Init/Tactics.v | destruct_all | |
find_equivH :=
let T := type of H in
lazymatch T with
| ?A -> ?B =>
let H1 := fresh in
let H2 := fresh in
cut A;
[intro H1; pose proof (H H1) as H2; clear H H1;
rename H2 into H; find_equiv H |
clear H]
| forall x : ?t, _ =>
let a := fresh "a" in
let H1 := fresh "H" in
evar (a : t); pose proof (H ... | Ltac | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Specif"
] | Corelib/Init/Tactics.v | find_equiv | |
bapplylemma todo :=
let H := fresh in
pose proof lemma as H;
find_equiv H; [todo H; clear H | .. ].
Tactic Notation "apply" "->" constr(lemma) :=
bapply lemma ltac:(fun H => destruct H as [H _]; apply H).
Tactic Notation "apply" "<-" constr(lemma) :=
bapply lemma ltac:(fun H => destruct H as [_ H]; apply H).
Tac... | Ltac | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Specif"
] | Corelib/Init/Tactics.v | bapply | |
easy:=
let rec use_hyp H :=
match type of H with
| _ /\ _ => exact H || destruct_hyp H
| _ => try solve [inversion H]
end
with do_intro := let H := fresh in intro H; use_hyp H
with destruct_hyp H := case H; clear H; do_intro; do_intro in
let rec use_hyps :=
match goal with
| H : _ /\ _ |... | Ltac | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Specif"
] | Corelib/Init/Tactics.v | easy | |
Ltac.easy_forward_decl ::= easy.
Tactic Notation "now" tactic(t) := t; easy. | Ltac | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Specif"
] | Corelib/Init/Tactics.v | Ltac | |
easy':= repeat split; simpl; easy || now destruct 1. | Ltac | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Specif"
] | Corelib/Init/Tactics.v | easy' | |
now_showc := change c. | Ltac | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Specif"
] | Corelib/Init/Tactics.v | now_show | |
decide_left: forall (C:Prop) (decide:{C}+{~C}),
C -> forall P:{C}+{~C}->Prop, (forall H:C, P (left _ H)) -> P decide.
Proof.
intros C decide H P H0; destruct decide.
- apply H0.
- contradiction.
Qed. | Lemma | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Specif"
] | Corelib/Init/Tactics.v | decide_left | |
decide_right: forall (C:Prop) (decide:{C}+{~C}),
~C -> forall P:{C}+{~C}->Prop, (forall H:~C, P (right _ H)) -> P decide.
Proof.
intros C decide H P H0; destruct decide.
- contradiction.
- apply H0.
Qed.
Tactic Notation "decide" constr(lemma) "with" constr(H) :=
let try_to_merge_hyps H :=
try (clear H; ... | Lemma | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Specif"
] | Corelib/Init/Tactics.v | decide_right | |
lookup_inversion_sigma_rectH :=
lazymatch type of H with
| ex_intro _ _ _ = ex_intro _ _ _
=> uconstr:(eq_ex_rect_ex_intro)
| exist _ _ _ = exist _ _ _
=> uconstr:(eq_sig_rect_exist)
| existT _ _ _ = existT _ _ _
=> uconstr:(eq_sigT_rect_existT)
| _ = ex_intro _ _ _
=> uconstr:(eq_ex_rect_ex_i... | Ltac | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Specif"
] | Corelib/Init/Tactics.v | lookup_inversion_sigma_rect | |
inversion_sigma_on_asH ip :=
let rect := lookup_inversion_sigma_rect H in
induction H as ip using rect. | Ltac | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Specif"
] | Corelib/Init/Tactics.v | inversion_sigma_on_as | |
inversion_sigma_onH := inversion_sigma_on_as H ipattern:([]). | Ltac | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Specif"
] | Corelib/Init/Tactics.v | inversion_sigma_on | |
inversion_sigma_step:=
match goal with
| [ H : _ |- _ ] => inversion_sigma_on H
end. | Ltac | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Specif"
] | Corelib/Init/Tactics.v | inversion_sigma_step | |
inversion_sigma:= repeat inversion_sigma_step.
Tactic Notation "inversion_sigma" := inversion_sigma.
Tactic Notation "inversion_sigma" hyp(H) := inversion_sigma_on H.
Tactic Notation "inversion_sigma" hyp(H) "as" simple_intropattern(ip) := inversion_sigma_on_as H ip. | Ltac | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Specif"
] | Corelib/Init/Tactics.v | inversion_sigma | |
time_constrtac :=
let eval_early := match goal with _ => restart_timer end in
let ret := tac () in
let eval_early := match goal with _ => finish_timing ( "Tactic evaluation" ) end in
ret. | Ltac | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Specif"
] | Corelib/Init/Tactics.v | time_constr | |
assert_failstac :=
tryif (once tac) then gfail 0 tac "succeeds" else idtac.
Tactic Notation "assert_fails" tactic3(tac) :=
assert_fails tac.
Create HintDb rewrite discriminated.
#[global]
Hint Variables Opaque : rewrite. | Ltac | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Specif"
] | Corelib/Init/Tactics.v | assert_fails | |
rapplyp := | Ltac | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Specif"
] | Corelib/Init/Tactics.v | rapply | |
tauto:= with_uniform_flags ltac:(fun flags => tauto_gen flags). | Ltac | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Datatypes",
"Require Import Logic"
] | Corelib/Init/Tauto.v | tauto | |
dtauto:= with_power_flags ltac:(fun flags => tauto_gen flags). | Ltac | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Datatypes",
"Require Import Logic"
] | Corelib/Init/Tauto.v | dtauto | |
intuition_solver:= auto.
Local Ltac intuition_then tac := with_uniform_flags ltac:(fun flags => intuition_gen flags tac). | Ltac | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Datatypes",
"Require Import Logic"
] | Corelib/Init/Tauto.v | intuition_solver | |
intuition:= intuition_then ltac:(idtac;intuition_solver).
Local Ltac dintuition_then tac := with_power_flags ltac:(fun flags => intuition_gen flags tac). | Ltac | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Datatypes",
"Require Import Logic"
] | Corelib/Init/Tauto.v | intuition | |
dintuition:= dintuition_then ltac:(idtac;intuition_solver).
Tactic Notation "intuition" := intuition.
Tactic Notation "intuition" tactic(t) := intuition_then t.
Tactic Notation "dintuition" := dintuition.
Tactic Notation "dintuition" tactic(t) := dintuition_then t. | Ltac | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Datatypes",
"Require Import Logic"
] | Corelib/Init/Tauto.v | dintuition | |
Acc(x: A) : Prop :=
Acc_intro : (forall y:A, R y x -> Acc y) -> Acc x.
Register Acc as core.wf.acc. | Inductive | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Datatypes"
] | Corelib/Init/Wf.v | Acc | |
Acc_inv: forall x:A, Acc x -> forall y:A, R y x -> Acc y.
destruct 1; trivial.
Defined.
Global Arguments Acc_inv [x] _ [y] _, [x] _ y _.
Register Acc_inv as core.wf.acc_inv. | Lemma | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Datatypes"
] | Corelib/Init/Wf.v | Acc_inv | |
well_founded:= forall a:A, Acc a.
Register well_founded as core.wf.well_founded. | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Datatypes"
] | Corelib/Init/Wf.v | well_founded | |
well_founded_induction_type:
forall P:A -> Type,
(forall x:A, (forall y:A, R y x -> P y) -> P x) -> forall a:A, P a.
Proof.
intros; apply Acc_rect; auto.
Defined. | Theorem | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Datatypes"
] | Corelib/Init/Wf.v | well_founded_induction_type | |
well_founded_induction:
forall P:A -> Set,
(forall x:A, (forall y:A, R y x -> P y) -> P x) -> forall a:A, P a.
Proof.
exact (fun P:A -> Set => well_founded_induction_type P).
Defined. | Theorem | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Datatypes"
] | Corelib/Init/Wf.v | well_founded_induction | |
well_founded_ind:
forall P:A -> Prop,
(forall x:A, (forall y:A, R y x -> P y) -> P x) -> forall a:A, P a.
Proof.
exact (fun P:A -> Prop => well_founded_induction_type P).
Defined. | Theorem | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Datatypes"
] | Corelib/Init/Wf.v | well_founded_ind | |
Fix_F(x:A) (a:Acc x) : P x :=
F (fun (y:A) (h:R y x) => Fix_F (Acc_inv a h)). | Fixpoint | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Datatypes"
] | Corelib/Init/Wf.v | Fix_F | |
Acc_inv_dep:= Induction for Acc Sort Prop. | Scheme | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Datatypes"
] | Corelib/Init/Wf.v | Acc_inv_dep | |
Fix_F_eq(x:A) (r:Acc x) :
F (fun (y:A) (p:R y x) => Fix_F (x:=y) (Acc_inv r p)) = Fix_F (x:=x) r.
Proof.
destruct r using Acc_inv_dep; auto.
Qed. | Lemma | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Datatypes"
] | Corelib/Init/Wf.v | Fix_F_eq | |
Fix(x:A) := Fix_F (Rwf x). | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Datatypes"
] | Corelib/Init/Wf.v | Fix | |
Fix_F_inv_gen: forall (x:A) (r s:Acc x), Fix_F r = Fix_F s.
Proof.
intro x; induction (Rwf x); intros r s.
rewrite <- (Fix_F_eq r); rewrite <- (Fix_F_eq s); intros.
apply F_ext; auto.
Qed. | Lemma | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Datatypes"
] | Corelib/Init/Wf.v | Fix_F_inv_gen | |
Fix_eq_gen: forall x:A, Fix x = F (fun (y:A) (p:R y x) => Fix y).
Proof.
intro x; unfold Fix.
rewrite <- Fix_F_eq.
apply F_ext; intros.
apply Fix_F_inv_gen.
Qed. | Lemma | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Datatypes"
] | Corelib/Init/Wf.v | Fix_eq_gen | |
Fix_F_inv: forall (x:A) (r s:Acc x), Fix_F r = Fix_F s.
Proof.
auto using Fix_F_inv_gen.
Qed. | Lemma | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Datatypes"
] | Corelib/Init/Wf.v | Fix_F_inv | |
Fix_eq: forall x:A, Fix x = F (fun (y:A) (p:R y x) => Fix y).
Proof.
auto using Fix_eq_gen.
Qed. | Lemma | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Datatypes"
] | Corelib/Init/Wf.v | Fix_eq | |
Fix_F_2(x:A) (x':B) (a:Acc R (x, x')) : P x x' :=
F
(fun (y:A) (y':B) (h:R (y, y') (x, x')) =>
Fix_F_2 (x:=y) (x':=y') (Acc_inv a (y,y') h)). | Fixpoint | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Datatypes"
] | Corelib/Init/Wf.v | Fix_F_2 | |
well_founded_induction_type_2:
(forall (x:A) (x':B),
(forall (y:A) (y':B), R (y, y') (x, x') -> P y y') -> P x x') ->
forall (a:A) (b:B), P a b.
Proof.
intros; apply Fix_F_2; auto.
Defined. | Theorem | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Datatypes"
] | Corelib/Init/Wf.v | well_founded_induction_type_2 | |
Acc_intro_generatorn (wf : well_founded R) :=
match n with
| O => wf
| S n => fun x => Acc_intro x (fun y _ => Acc_intro_generator n (Acc_intro_generator n wf) y)
end. | Fixpoint | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic",
"Require Import Datatypes"
] | Corelib/Init/Wf.v | Acc_intro_generator | |
map(l:list A) : list B :=
match l with
| nil => nil
| a :: l => (f a) :: (map l)
end. | Fixpoint | Corelib | [] | Corelib/Lists/ListDef.v | map | |
seq(start len:nat) : list nat :=
match len with
| 0 => nil
| S len => start :: seq (S start) len
end. | Fixpoint | Corelib | [] | Corelib/Lists/ListDef.v | seq | |
repeat(x : A) (n: nat ) :=
match n with
| O => nil
| S k => x :: repeat x k
end. | Fixpoint | Corelib | [] | Corelib/Lists/ListDef.v | repeat | |
nth(n:nat) (l:list A) (default:A) {struct l} : A :=
match n, l with
| O, x :: l' => x
| O, nil => default
| S m, nil => default
| S m, x :: l' => nth m l' default
end. | Fixpoint | Corelib | [] | Corelib/Lists/ListDef.v | nth | |
firstn(n:nat) (l:list A) : list A :=
match n with
| 0 => nil
| S n => match l with
| nil => nil
| a::l => a::(firstn n l)
end
end. | Fixpoint | Corelib | [] | Corelib/Lists/ListDef.v | firstn | |
skipn(n:nat) (l:list A) : list A :=
match n with
| 0 => l
| S n => match l with
| nil => nil
| a::l => skipn n l
end
end. | Fixpoint | Corelib | [] | Corelib/Lists/ListDef.v | skipn | |
Forall: list A -> Prop :=
| Forall_nil : Forall nil
| Forall_cons : forall x l, P x -> Forall l -> Forall (x :: l). | Inductive | Corelib | [] | Corelib/Lists/ListDef.v | Forall | |
list_compare(xs ys : list A) : comparison :=
match xs, ys with
| nil , nil => Eq
| nil , _ => Lt
| _ , nil => Gt
| x :: xs, y :: ys =>
match cmp x y with
| Eq => list_compare xs ys
| c => c
end
end%list. | Fixpoint | Corelib | [] | Corelib/Lists/ListDef.v | list_compare | |
positive: Set :=
| xI : positive -> positive
| xO : positive -> positive
| xH : positive.
Declare Scope positive_scope.
Delimit Scope positive_scope with positive.
Bind Scope positive_scope with positive.
Arguments xO _%_positive.
Arguments xI _%_positive.
Declare Scope hex_positive_scope.
Delimit Scope hex_pos... | Inductive | Corelib | [] | Corelib/Numbers/BinNums.v | positive | |
N: Set :=
| N0 : N
| Npos : positive -> N.
Declare Scope N_scope.
Delimit Scope N_scope with N.
Bind Scope N_scope with N.
Arguments Npos _%_positive.
Declare Scope hex_N_scope.
Delimit Scope hex_N_scope with xN.
Register N as num.N.type.
Register N0 as num.N.N0.
Register Npos as num.N.Npos. | Inductive | Corelib | [] | Corelib/Numbers/BinNums.v | N | |
Z: Set :=
| Z0 : Z
| Zpos : positive -> Z
| Zneg : positive -> Z.
Declare Scope Z_scope.
Delimit Scope Z_scope with Z.
Bind Scope Z_scope with Z.
Arguments Zpos _%_positive.
Arguments Zneg _%_positive.
Declare Scope hex_Z_scope.
Delimit Scope hex_Z_scope with xZ.
Register Z as num.Z.type.
Register Z0 as num.Z.... | Inductive | Corelib | [] | Corelib/Numbers/BinNums.v | Z | |
compose{A B C} (g : B -> C) (f : A -> B) :=
fun x : A => g (f x).
#[global]
Hint Unfold compose : core.
Declare Scope program_scope. | Definition | Corelib | [] | Corelib/Program/Basics.v | compose | |
arrow(A B : Type) := A -> B.
Register arrow as core.arrow. | Definition | Corelib | [] | Corelib/Program/Basics.v | arrow | |
impl(A B : Prop) : Prop := A -> B.
Register impl as core.impl. | Definition | Corelib | [] | Corelib/Program/Basics.v | impl | |
const{A B} (a : A) := fun _ : B => a. | Definition | Corelib | [] | Corelib/Program/Basics.v | const | |
flip{A B C} (f : A -> B -> C) x y := f y x.
Register flip as core.flip. | Definition | Corelib | [] | Corelib/Program/Basics.v | flip | |
apply{A B} (f : A -> B) (x : A) := f x. | Definition | Corelib | [] | Corelib/Program/Basics.v | apply | |
show_goal:= match goal with [ |- ?T ] => idtac T end. | Ltac | Corelib | [] | Corelib/Program/Tactics.v | show_goal | |
show_hypid :=
match goal with
| [ H := ?b : ?T |- _ ] =>
match H with
| id => idtac id ":=" b ":" T
end
| [ H : ?T |- _ ] =>
match H with
| id => idtac id ":" T
end
end. | Ltac | Corelib | [] | Corelib/Program/Tactics.v | show_hyp | |
show_hyps:=
try match reverse goal with
| [ H : ?T |- _ ] => show_hyp H ; fail
end. | Ltac | Corelib | [] | Corelib/Program/Tactics.v | show_hyps | |
do_natn tac :=
match n with
| 0 => idtac
| S ?n' => tac ; do_nat n' tac
end. | Ltac | Corelib | [] | Corelib/Program/Tactics.v | do_nat | |
on_last_hyptac :=
lazymatch goal with [ H : _ |- _ ] => tac H end. | Ltac | Corelib | [] | Corelib/Program/Tactics.v | on_last_hyp | |
destruct_one_pair:=
match goal with
| [H : (_ /\ _) |- _] => destruct H
| [H : prod _ _ |- _] => destruct H
end. | Ltac | Corelib | [] | Corelib/Program/Tactics.v | destruct_one_pair | |
destruct_pairs:= repeat (destruct_one_pair). | Ltac | Corelib | [] | Corelib/Program/Tactics.v | destruct_pairs | |
destruct_one_ex:=
let tac H := let ph := fresh "H" in (destruct H as [H ph]) in
let tac2 H := let ph := fresh "H" in let ph' := fresh "H" in
(destruct H as [H ph ph'])
in
let tacT H := let ph := fresh "X" in (destruct H as [H ph]) in
let tacT2 H := let ph := fresh "X" in let ph' := fresh "X" in
(destr... | Ltac | Corelib | [] | Corelib/Program/Tactics.v | destruct_one_ex | |
destruct_exists:= repeat (destruct_one_ex). | Ltac | Corelib | [] | Corelib/Program/Tactics.v | destruct_exists | |
destruct_conjs:= repeat (destruct_one_pair || destruct_one_ex). | Ltac | Corelib | [] | Corelib/Program/Tactics.v | destruct_conjs | |
discriminates:=
match goal with
| [ H : ?x <> ?x |- _ ] => elim H ; reflexivity
| _ => discriminate
end. | Ltac | Corelib | [] | Corelib/Program/Tactics.v | discriminates | |
revert_last:=
match goal with
[ H : _ |- _ ] => revert H
end. | Ltac | Corelib | [] | Corelib/Program/Tactics.v | revert_last | |
reverse:= repeat revert_last. | Ltac | Corelib | [] | Corelib/Program/Tactics.v | reverse | |
revert_untilid :=
on_last_hyp ltac:(fun id' =>
match id' with
| id => idtac
| _ => revert id' ; revert_until id
end). | Ltac | Corelib | [] | Corelib/Program/Tactics.v | revert_until | |
clear_dup:=
match goal with
| [ H : ?X |- _ ] =>
match goal with
| [ H' : ?Y |- _ ] =>
match H with
| H' => fail 2
| _ => unify X Y ; (clear H' || clear H)
end
end
end. | Ltac | Corelib | [] | Corelib/Program/Tactics.v | clear_dup | |
clear_dups:= repeat clear_dup. | Ltac | Corelib | [] | Corelib/Program/Tactics.v | clear_dups | |
clear_excepthyp :=
repeat match goal with [ H : _ |- _ ] =>
match H with
| hyp => fail 1
| _ => clear H
end
end. | Ltac | Corelib | [] | Corelib/Program/Tactics.v | clear_except | |
subst_no_fail:=
repeat (match goal with
[ H : ?X = ?Y |- _ ] => subst X || subst Y
end).
Tactic Notation "subst" "*" := subst_no_fail. | Ltac | Corelib | [] | Corelib/Program/Tactics.v | subst_no_fail | |
on_applicationf tac T :=
match T with
| context [f ?x ?y ?z ?w ?v ?u ?a ?b ?c] => tac (f x y z w v u a b c)
| context [f ?x ?y ?z ?w ?v ?u ?a ?b] => tac (f x y z w v u a b)
| context [f ?x ?y ?z ?w ?v ?u ?a] => tac (f x y z w v u a)
| context [f ?x ?y ?z ?w ?v ?u] => tac (f x y z w v u)
| context ... | Ltac | Corelib | [] | Corelib/Program/Tactics.v | on_application | |
on_callf tac :=
match goal with
| |- ?T => on_application f tac T
| H : ?T |- _ => on_application f tac T
end. | Ltac | Corelib | [] | Corelib/Program/Tactics.v | on_call | |
destruct_callf :=
let tac t := (destruct t) in on_call f tac. | Ltac | Corelib | [] | Corelib/Program/Tactics.v | destruct_call | |
destruct_callsf := repeat destruct_call f. | Ltac | Corelib | [] | Corelib/Program/Tactics.v | destruct_calls |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.