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 |
|---|---|---|---|---|---|---|
SFulpx := SFldexp SFone (fexp (snd (SFfrexp x))). | Definition | Corelib | [
"From Corelib Require Import BinNums PosDef IntDef FloatClass"
] | Corelib/Floats/SpecFloat.v | SFulp | |
SFpred_posx :=
match x with
| S754_finite _ mx _ =>
let d :=
if Pos.eqb mx~0 (Pos.iter xO xH (Z.to_pos prec)) then
SFldexp SFone (fexp (Z.sub (snd (SFfrexp x)) (Zpos 1)))
else
SFulp x in
SFsub x d
| _ => x
end. | Definition | Corelib | [
"From Corelib Require Import BinNums PosDef IntDef FloatClass"
] | Corelib/Floats/SpecFloat.v | SFpred_pos | |
SFmax_float:=
S754_finite false (Pos.sub (Pos.iter xO xH (Z.to_pos prec)) 1) (Z.sub emax prec). | Definition | Corelib | [
"From Corelib Require Import BinNums PosDef IntDef FloatClass"
] | Corelib/Floats/SpecFloat.v | SFmax_float | |
SFsuccx :=
match x with
| S754_zero _ => SFldexp SFone emin
| S754_infinity false => x
| S754_infinity true => SFopp SFmax_float
| S754_nan => x
| S754_finite false _ _ => SFadd x (SFulp x)
| S754_finite true _ _ => SFopp (SFpred_pos (SFopp x))
end. | Definition | Corelib | [
"From Corelib Require Import BinNums PosDef IntDef FloatClass"
] | Corelib/Floats/SpecFloat.v | SFsucc | |
SFpredf := SFopp (SFsucc (SFopp f)). | Definition | Corelib | [
"From Corelib Require Import BinNums PosDef IntDef FloatClass"
] | Corelib/Floats/SpecFloat.v | SFpred | |
byte:=
| x00
| x01
| x02
| x03
| x04
| x05
| x06
| x07
| x08
| x09
| x0a
| x0b
| x0c
| x0d
| x0e
| x0f
| x10
| x11
| x12
| x13
| x14
| x15
| x16
| x17
| x18
| x19
| x1a
| x1b
| x1c
| x1d
| x1e
| x1f
| x20
| x21
| x22
| x23
| x24
| x25
| x26
| x27
| x28
| x29
| x2a
| x2b
| x2c
| x2d
| x2e
| x2f
| x30
... | Inductive | Corelib | [
"Require Import Corelib.Init.Ltac",
"Require Import Corelib.Init.Datatypes",
"Require Import Corelib.Init.Logic",
"Require Import Corelib.Init.Specif",
"Require Corelib.Init.Nat"
] | Corelib/Init/Byte.v | byte | |
of_bits(b : bool * (bool * (bool * (bool * (bool * (bool * (bool * bool))))))) : byte
:= match b with
| (0,(0,(0,(0,(0,(0,(0,0))))))) => x00
| (1,(0,(0,(0,(0,(0,(0,0))))))) => x01
| (0,(1,(0,(0,(0,(0,(0,0))))))) => x02
| (1,(1,(0,(0,(0,(0,(0,0))))))) => x03
| (0,(0,(1,(0,(0,(0,(0,0))))))) => ... | Definition | Corelib | [
"Require Import Corelib.Init.Ltac",
"Require Import Corelib.Init.Datatypes",
"Require Import Corelib.Init.Logic",
"Require Import Corelib.Init.Specif",
"Require Corelib.Init.Nat"
] | Corelib/Init/Byte.v | of_bits | |
to_bits(b : byte) : bool * (bool * (bool * (bool * (bool * (bool * (bool * bool))))))
:= match b with
| x00 => (0,(0,(0,(0,(0,(0,(0,0)))))))
| x01 => (1,(0,(0,(0,(0,(0,(0,0)))))))
| x02 => (0,(1,(0,(0,(0,(0,(0,0)))))))
| x03 => (1,(1,(0,(0,(0,(0,(0,0)))))))
| x04 => (0,(0,(1,(0,(0,(0,(0,0))))... | Definition | Corelib | [
"Require Import Corelib.Init.Ltac",
"Require Import Corelib.Init.Datatypes",
"Require Import Corelib.Init.Logic",
"Require Import Corelib.Init.Specif",
"Require Corelib.Init.Nat"
] | Corelib/Init/Byte.v | to_bits | |
of_bits_to_bits(b : byte) : of_bits (to_bits b) = b.
Proof. destruct b; exact eq_refl. Qed. | Lemma | Corelib | [
"Require Import Corelib.Init.Ltac",
"Require Import Corelib.Init.Datatypes",
"Require Import Corelib.Init.Logic",
"Require Import Corelib.Init.Specif",
"Require Corelib.Init.Nat"
] | Corelib/Init/Byte.v | of_bits_to_bits | |
to_bits_of_bits(b : _) : to_bits (of_bits b) = b.
Proof.
repeat match goal with
| p : prod _ _ |- _ => destruct p
| b : bool |- _ => destruct b
end;
exact eq_refl.
Qed. | Lemma | Corelib | [
"Require Import Corelib.Init.Ltac",
"Require Import Corelib.Init.Datatypes",
"Require Import Corelib.Init.Logic",
"Require Import Corelib.Init.Specif",
"Require Corelib.Init.Nat"
] | Corelib/Init/Byte.v | to_bits_of_bits | |
byte_of_byte(b : byte) : byte := b. | Definition | Corelib | [
"Require Import Corelib.Init.Ltac",
"Require Import Corelib.Init.Datatypes",
"Require Import Corelib.Init.Logic",
"Require Import Corelib.Init.Specif",
"Require Corelib.Init.Nat"
] | Corelib/Init/Byte.v | byte_of_byte | |
Empty_set: Set :=.
Register Empty_set as core.Empty_set.type. | Inductive | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | Empty_set | |
unit: Set :=
tt : unit.
Register unit as core.unit.type.
Register tt as core.unit.tt. | Inductive | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | unit | |
bool: Set :=
| true : bool
| false : bool.
Add Printing If bool.
Declare Scope bool_scope.
Delimit Scope bool_scope with bool.
Bind Scope bool_scope with bool.
Register bool as core.bool.type.
Register true as core.bool.true.
Register false as core.bool.false. | Inductive | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | bool | |
reflect(P : Prop) : bool -> Set :=
| ReflectT : P -> reflect P true
| ReflectF : ~ P -> reflect P false.
#[global]
Create HintDb bool.
#[global]
Hint Constructors reflect : bool.
Arguments ReflectT : clear implicits.
Arguments ReflectF : clear implicits. | Inductive | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | reflect | |
andb(b1 b2:bool) : bool := if b1 then b2 else false. | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | andb | |
orb(b1 b2:bool) : bool := if b1 then true else b2. | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | orb | |
implb(b1 b2:bool) : bool := if b1 then b2 else true. | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | implb | |
xorb(b1 b2:bool) : bool :=
if b1 then
if b2 then false else true
else b2. | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | xorb | |
negb(b:bool) := if b then false else true.
Infix "||" := orb : bool_scope.
Infix "&&" := andb : bool_scope.
Register andb as core.bool.andb.
Register orb as core.bool.orb.
Register implb as core.bool.implb.
Register xorb as core.bool.xorb.
Register negb as core.bool.negb. | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | negb | |
andb_prop(a b:bool) : andb a b = true -> a = true /\ b = true.
Proof.
destruct a, b; repeat split; assumption.
Qed.
#[global]
Hint Resolve andb_prop: bool.
Register andb_prop as core.bool.andb_prop. | Lemma | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | andb_prop | |
andb_true_intro(b1 b2:bool) :
b1 = true /\ b2 = true -> andb b1 b2 = true.
Proof.
destruct b1; destruct b2; simpl; intros [? ?]; assumption.
Qed.
#[global]
Hint Resolve andb_true_intro: bool.
Register andb_true_intro as core.bool.andb_true_intro. | Lemma | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | andb_true_intro | |
eq_true: bool -> Prop := is_eq_true : eq_true true.
#[global]
Create HintDb eq_true.
#[global]
Hint Constructors eq_true : eq_true.
Register eq_true as core.eq_true.type. | Inductive | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | eq_true | |
Rewritingfor eq_true. | Scheme | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | Rewriting | |
is_trueb := b = true. | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | is_true | |
eq_true_ind_r:
forall (P : bool -> Prop) (b : bool), P b -> eq_true b -> P true.
Proof.
intros P b H H0; destruct H0 in H; assumption.
Defined. | Lemma | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | eq_true_ind_r | |
eq_true_rec_r:
forall (P : bool -> Set) (b : bool), P b -> eq_true b -> P true.
Proof.
intros P b H H0; destruct H0 in H; assumption.
Defined. | Lemma | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | eq_true_rec_r | |
eq_true_rect_r:
forall (P : bool -> Type) (b : bool), P b -> eq_true b -> P true.
Proof.
intros P b H H0; destruct H0 in H; assumption.
Defined. | Lemma | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | eq_true_rect_r | |
BoolSpec(P Q : Prop) : bool -> Prop :=
| BoolSpecT : P -> BoolSpec P Q true
| BoolSpecF : Q -> BoolSpec P Q false.
#[global]
Hint Constructors BoolSpec : core.
Register BoolSpec as core.BoolSpec.type.
Register BoolSpecT as core.BoolSpec.BoolSpecT.
Register BoolSpecF as core.BoolSpec.BoolSpecF. | Inductive | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | BoolSpec | |
nat: Set :=
| O : nat
| S : nat -> nat.
Declare Scope hex_nat_scope.
Delimit Scope hex_nat_scope with xnat.
Declare Scope nat_scope.
Delimit Scope nat_scope with nat.
Bind Scope nat_scope with nat.
Arguments S _%_nat.
Register nat as num.nat.type.
Register O as num.nat.O.
Register S as num.nat.S. | Inductive | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | nat | |
option(A:Type) : Type :=
| Some : A -> option A
| None : option A.
Arguments Some {A} a.
Arguments None {A}.
Register option as core.option.type.
Register Some as core.option.Some.
Register None as core.option.None. | Inductive | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | option | |
option_map(A B:Type) (f:A->B) (o : option A) : option B :=
match o with
| Some a => @Some B (f a)
| None => @None B
end. | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | option_map | |
sum(A B:Type) : Type :=
| inl : A -> sum A B
| inr : B -> sum A B. | Inductive | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | sum | |
result(A E : Type) :=
| Ok (_:A)
| Error (_:E).
Arguments Ok {_ _} _, [_] _ _.
Arguments Error {_ _} _, _ [_] _.
Register result as core.result.type. | Inductive | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | result | |
prod(A B:Type) : Type :=
pair : A -> B -> A * B
where "x * y" := (prod x y) : type_scope.
Add Printing Let prod. | Inductive | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | prod | |
fst(p:A * B) := match p with (x, y) => x end. | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | fst | |
snd(p:A * B) := match p with (x, y) => y end.
Register fst as core.prod.proj1.
Register snd as core.prod.proj2. | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | snd | |
surjective_pairing(A B:Type) (p:A * B) : p = (fst p, snd p).
Proof.
destruct p; reflexivity.
Qed. | Lemma | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | surjective_pairing | |
injective_projections(A B:Type) (p1 p2:A * B) :
fst p1 = fst p2 -> snd p1 = snd p2 -> p1 = p2.
Proof.
destruct p1; destruct p2; simpl; intros Hfst Hsnd.
rewrite Hfst; rewrite Hsnd; reflexivity.
Qed. | Lemma | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | injective_projections | |
pair_equal_spec(A B : Type) (a1 a2 : A) (b1 b2 : B) :
(a1, b1) = (a2, b2) <-> a1 = a2 /\ b1 = b2.
Proof.
split; intro H.
- split.
+ replace a1 with (fst (a1, b1)); replace a2 with (fst (a2, b2)); auto.
rewrite H; auto.
+ replace b1 with (snd (a1, b1)); replace b2 with (snd (a2, b2)); auto.
r... | Lemma | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | pair_equal_spec | |
curry{A B C:Type} (f:A * B -> C)
(x:A) (y:B) : C := f (x,y). | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | curry | |
uncurry{A B C:Type} (f:A -> B -> C)
(p:A * B) : C := match p with (x, y) => f x y end.
Import EqNotations. | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | uncurry | |
rew_pairA (P Q : A->Type) x1 x2 (y1:P x1) (y2:Q x1) (H:x1=x2) :
(rew H in y1, rew H in y2) = rew [fun x => (P x * Q x)%type] H in (y1,y2).
Proof.
destruct H. reflexivity.
Defined. | Lemma | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | rew_pair | |
list(A : Type) : Type :=
| nil : list A
| cons : A -> list A -> list A.
Arguments nil {A}.
Arguments cons {A} a l.
Declare Scope list_scope.
Delimit Scope list_scope with list.
Bind Scope list_scope with list.
Infix "::" := cons (at level 60, right associativity) : list_scope.
Register list as core.list.type.
Reg... | Inductive | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | list | |
length(A : Type) : list A -> nat :=
fix length l :=
match l with
| nil => O
| _ :: l' => S (length l')
end. | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | length | |
app(A : Type) : list A -> list A -> list A :=
fix app l m :=
match l with
| nil => m
| a :: l1 => a :: app l1 m
end.
Infix "++" := app (right associativity, at level 60) : list_scope. | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | app | |
comparison: Set :=
| Eq : comparison
| Lt : comparison
| Gt : comparison.
Register comparison as core.comparison.type.
Register Eq as core.comparison.Eq.
Register Lt as core.comparison.Lt.
Register Gt as core.comparison.Gt. | Inductive | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | comparison | |
comparison_eq_stable(c c' : comparison) : ~~ c = c' -> c = c'.
Proof.
destruct c, c'; intro H; reflexivity || destruct H; discriminate.
Qed. | Lemma | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | comparison_eq_stable | |
CompOpp(r:comparison) :=
match r with
| Eq => Eq
| Lt => Gt
| Gt => Lt
end. | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | CompOpp | |
CompOpp_involutivec : CompOpp (CompOpp c) = c.
Proof.
destruct c; reflexivity.
Qed. | Lemma | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | CompOpp_involutive | |
CompOpp_injc c' : CompOpp c = CompOpp c' -> c = c'.
Proof.
destruct c; destruct c'; auto; discriminate.
Qed. | Lemma | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | CompOpp_inj | |
CompOpp_iff: forall c c', CompOpp c = c' <-> c = CompOpp c'.
Proof.
split; intros; apply CompOpp_inj; rewrite CompOpp_involutive; auto.
Qed. | Lemma | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | CompOpp_iff | |
CompareSpec(Peq Plt Pgt : Prop) : comparison -> Prop :=
| CompEq : Peq -> CompareSpec Peq Plt Pgt Eq
| CompLt : Plt -> CompareSpec Peq Plt Pgt Lt
| CompGt : Pgt -> CompareSpec Peq Plt Pgt Gt.
#[global]
Hint Constructors CompareSpec : core.
Register CompareSpec as core.CompareSpec.type.
Register CompEq as core.Compa... | Inductive | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | CompareSpec | |
CompareSpecT(Peq Plt Pgt : Prop) : comparison -> Type :=
| CompEqT : Peq -> CompareSpecT Peq Plt Pgt Eq
| CompLtT : Plt -> CompareSpecT Peq Plt Pgt Lt
| CompGtT : Pgt -> CompareSpecT Peq Plt Pgt Gt.
#[global]
Hint Constructors CompareSpecT : core.
Register CompareSpecT as core.CompareSpecT.type.
Register CompEqT as... | Inductive | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | CompareSpecT | |
CompareSpec2TypePeq Plt Pgt c :
CompareSpec Peq Plt Pgt c -> CompareSpecT Peq Plt Pgt c.
Proof.
destruct c; intros H; constructor; inversion_clear H; auto.
Defined. | Lemma | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | CompareSpec2Type | |
CompSpec{A} (eq lt : A->A->Prop)(x y:A) : comparison -> Prop :=
CompareSpec (eq x y) (lt x y) (lt y x). | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | CompSpec | |
CompSpecT{A} (eq lt : A->A->Prop)(x y:A) : comparison -> Type :=
CompareSpecT (eq x y) (lt x y) (lt y x).
#[global]
Hint Unfold CompSpec CompSpecT : core. | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | CompSpecT | |
CompSpec2Type: forall A (eq lt:A->A->Prop) x y c,
CompSpec eq lt x y c -> CompSpecT eq lt x y c.
Proof. intros. apply CompareSpec2Type; assumption. Defined. | Lemma | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | CompSpec2Type | |
ID:= forall A:Type, A -> A. | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | ID | |
id: ID := fun A x => x. | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | id | |
IDProp:= forall A:Prop, A -> A. | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | IDProp | |
idProp: IDProp := fun A x => x.
Register idProp as core.IDProp.idProp. | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac",
"Require Import Logic"
] | Corelib/Init/Datatypes.v | idProp | |
uint:=
| Nil
| D0 (_:uint)
| D1 (_:uint)
| D2 (_:uint)
| D3 (_:uint)
| D4 (_:uint)
| D5 (_:uint)
| D6 (_:uint)
| D7 (_:uint)
| D8 (_:uint)
| D9 (_:uint). | Inductive | Corelib | [
"Require Import Datatypes Specif"
] | Corelib/Init/Decimal.v | uint | |
signed_int:= Pos (d:uint) | Neg (d:uint).
Abbreviation int := signed_int. | Variant | Corelib | [
"Require Import Datatypes Specif"
] | Corelib/Init/Decimal.v | signed_int | |
decimal:=
| Decimal (i:int) (f:uint)
| DecimalExp (i:int) (f:uint) (e:int). | Variant | Corelib | [
"Require Import Datatypes Specif"
] | Corelib/Init/Decimal.v | decimal | |
Equalityfor uint. | Scheme | Corelib | [
"Require Import Datatypes Specif"
] | Corelib/Init/Decimal.v | Equality | |
Equalityfor int. | Scheme | Corelib | [
"Require Import Datatypes Specif"
] | Corelib/Init/Decimal.v | Equality | |
Equalityfor decimal.
Abbreviation int_eq_dec := signed_int_eq_dec.
Abbreviation int_beq := signed_int_beq.
Abbreviation internal_int_dec_lb := internal_signed_int_dec_lb.
Abbreviation internal_int_dec_bl := internal_signed_int_dec_bl.
Declare Scope dec_uint_scope.
Delimit Scope dec_uint_scope with uint.
Bind Scope dec... | Scheme | Corelib | [
"Require Import Datatypes Specif"
] | Corelib/Init/Decimal.v | Equality | |
nb_digitsd :=
match d with
| Nil => O
| D0 d | D1 d | D2 d | D3 d | D4 d | D5 d | D6 d | D7 d | D8 d | D9 d =>
S (nb_digits d)
end. | Fixpoint | Corelib | [
"Require Import Datatypes Specif"
] | Corelib/Init/Decimal.v | nb_digits | |
nzheadd :=
match d with
| D0 d => nzhead d
| _ => d
end. | Fixpoint | Corelib | [
"Require Import Datatypes Specif"
] | Corelib/Init/Decimal.v | nzhead | |
unormd :=
match nzhead d with
| Nil => zero
| d => d
end. | Definition | Corelib | [
"Require Import Datatypes Specif"
] | Corelib/Init/Decimal.v | unorm | |
normd :=
match d with
| Pos d => Pos (unorm d)
| Neg d =>
match nzhead d with
| Nil => Pos zero
| d => Neg d
end
end. | Definition | Corelib | [
"Require Import Datatypes Specif"
] | Corelib/Init/Decimal.v | norm | |
opp(d:int) :=
match d with
| Pos d => Neg d
| Neg d => Pos d
end. | Definition | Corelib | [
"Require Import Datatypes Specif"
] | Corelib/Init/Decimal.v | opp | |
abs(d:int) : uint :=
match d with
| Pos d => d
| Neg d => d
end. | Definition | Corelib | [
"Require Import Datatypes Specif"
] | Corelib/Init/Decimal.v | abs | |
revapp(d d' : uint) :=
match d with
| Nil => d'
| D0 d => revapp d (D0 d')
| D1 d => revapp d (D1 d')
| D2 d => revapp d (D2 d')
| D3 d => revapp d (D3 d')
| D4 d => revapp d (D4 d')
| D5 d => revapp d (D5 d')
| D6 d => revapp d (D6 d')
| D7 d => revapp d (D7 d')
| D8 d => revapp d (D8 d')
| D9 ... | Fixpoint | Corelib | [
"Require Import Datatypes Specif"
] | Corelib/Init/Decimal.v | revapp | |
revd := revapp d Nil. | Definition | Corelib | [
"Require Import Datatypes Specif"
] | Corelib/Init/Decimal.v | rev | |
appd d' := revapp (rev d) d'. | Definition | Corelib | [
"Require Import Datatypes Specif"
] | Corelib/Init/Decimal.v | app | |
app_intd1 d2 :=
match d1 with Pos d1 => Pos (app d1 d2) | Neg d1 => Neg (app d1 d2) end. | Definition | Corelib | [
"Require Import Datatypes Specif"
] | Corelib/Init/Decimal.v | app_int | |
nztaild :=
let fix aux d_rev :=
match d_rev with
| D0 d_rev => let (r, n) := aux d_rev in pair r (S n)
| _ => pair d_rev O
end in
let (r, n) := aux (rev d) in pair (rev r) n. | Definition | Corelib | [
"Require Import Datatypes Specif"
] | Corelib/Init/Decimal.v | nztail | |
nztail_intd :=
match d with
| Pos d => let (r, n) := nztail d in pair (Pos r) n
| Neg d => let (r, n) := nztail d in pair (Neg r) n
end. | Definition | Corelib | [
"Require Import Datatypes Specif"
] | Corelib/Init/Decimal.v | nztail_int | |
del_headn d :=
match n with
| O => d
| S n =>
match d with
| Nil => zero
| D0 d | D1 d | D2 d | D3 d | D4 d | D5 d | D6 d | D7 d | D8 d | D9 d =>
del_head n d
end
end. | Fixpoint | Corelib | [
"Require Import Datatypes Specif"
] | Corelib/Init/Decimal.v | del_head | |
del_head_intn d :=
match d with
| Pos d => del_head n d
| Neg d => del_head n d
end. | Definition | Corelib | [
"Require Import Datatypes Specif"
] | Corelib/Init/Decimal.v | del_head_int | |
del_tailn d := rev (del_head n (rev d)). | Definition | Corelib | [
"Require Import Datatypes Specif"
] | Corelib/Init/Decimal.v | del_tail | |
del_tail_intn d :=
match d with
| Pos d => Pos (del_tail n d)
| Neg d => Neg (del_tail n d)
end. | Definition | Corelib | [
"Require Import Datatypes Specif"
] | Corelib/Init/Decimal.v | del_tail_int | |
succd :=
match d with
| Nil => D1 Nil
| D0 d => D1 d
| D1 d => D2 d
| D2 d => D3 d
| D3 d => D4 d
| D4 d => D5 d
| D5 d => D6 d
| D6 d => D7 d
| D7 d => D8 d
| D8 d => D9 d
| D9 d => D0 (succ d)
end. | Fixpoint | Corelib | [
"Require Import Datatypes Specif"
] | Corelib/Init/Decimal.v | succ | |
doubled :=
match d with
| Nil => Nil
| D0 d => D0 (double d)
| D1 d => D2 (double d)
| D2 d => D4 (double d)
| D3 d => D6 (double d)
| D4 d => D8 (double d)
| D5 d => D0 (succ_double d)
| D6 d => D2 (succ_double d)
| D7 d => D4 (succ_double d)
| D8 d => D6 (succ_double d)
| D9 d => D8 (succ_doub... | Fixpoint | Corelib | [
"Require Import Datatypes Specif"
] | Corelib/Init/Decimal.v | double | |
uint_of_uint(i:uint) := i. | Definition | Corelib | [
"Require Import Datatypes Specif"
] | Corelib/Init/Decimal.v | uint_of_uint | |
int_of_int(i:int) := i. | Definition | Corelib | [
"Require Import Datatypes Specif"
] | Corelib/Init/Decimal.v | int_of_int | |
Has_refl@{sa se;la le} (eq : forall A : Type@{sa;la}, A -> A -> Type@{se;le})
:= refl : forall A x, eq A x x. | Class | Corelib | [
"Require Import Notations",
"Require Import Ltac"
] | Corelib/Init/Equality.v | Has_refl | |
Has_J@{sa se sp;la le lp} (eq : forall A : Type@{sa ; la}, A -> A -> Type@{se;le})
(Has_refl : Has_refl eq) :=
J_eliminator : forall (A : Type@{sa ; la}) (x : A) (P : forall y : A, eq A x y -> Type@{sp ; lp}),
P x (refl A x) -> forall y e, P y e. | Class | Corelib | [
"Require Import Notations",
"Require Import Ltac"
] | Corelib/Init/Equality.v | Has_J | |
Has_J_r@{sa se sp;la le lp} (eq : forall A : Type@{sa ; la}, A -> A -> Type@{se;le})
(Has_refl : Has_refl eq) :=
J_r_eliminator: forall (A : Type@{sa ; la}) (x : A) (P : forall y : A, eq A y x -> Type@{sp ; lp}),
P x (refl A x) -> forall y e, P y e. | Class | Corelib | [
"Require Import Notations",
"Require Import Ltac"
] | Corelib/Init/Equality.v | Has_J_r | |
Has_J_forward@{sa se sp;la le lp} (eq : forall A : Type@{sa ; la}, A -> A -> Type@{se;le})
(Has_refl : Has_refl eq) :=
J_forward : forall (A : Type@{sa ; la}) (x : A) (P : forall y : A, eq A x y -> Type@{sp ; lp}) y e,
P y e -> P x (refl A x). | Class | Corelib | [
"Require Import Notations",
"Require Import Ltac"
] | Corelib/Init/Equality.v | Has_J_forward | |
Has_J_r_forward@{sa se sp;la le lp} (eq : forall A : Type@{sa ; la}, A -> A -> Type@{se;le})
(Has_refl : Has_refl eq) :=
J_r_forward : forall (A : Type@{sa ; la}) (x : A) (P : forall y : A, eq A y x -> Type@{sp ; lp}) y e,
P y e -> P x (refl A x). | Class | Corelib | [
"Require Import Notations",
"Require Import Ltac"
] | Corelib/Init/Equality.v | Has_J_r_forward | |
Has_Leibniz@{sa se sp;la le lp} (eq : forall A : Type@{sa ; la}, A -> A -> Type@{se;le}) :=
leibniz : forall (A : Type@{sa ; la}) (x : A) (P : A -> Type@{sp ; lp}), P x -> forall y, eq A x y -> P y. | Class | Corelib | [
"Require Import Notations",
"Require Import Ltac"
] | Corelib/Init/Equality.v | Has_Leibniz | |
Has_Leibniz_r@{sa se sp;la le lp} (eq : forall A : Type@{sa ; la}, A -> A -> Type@{se;le}) :=
leibniz_r : forall (A : Type@{sa ; la}) (x : A) (P : A -> Type@{sp ; lp}), P x -> forall y, eq A y x -> P y.
Register Has_refl as core.Has_refl.
Typeclasses Opaque Has_refl.
Register Has_J as core.Has_J.
Typeclasses Opaque... | Class | Corelib | [
"Require Import Notations",
"Require Import Ltac"
] | Corelib/Init/Equality.v | Has_Leibniz_r | |
J_no_dep@{s s' sp;l l' lp} {eq} {refl} (eqr : Has_J@{s s' sp;l l' lp} eq refl) :
forall (A : Type@{s ; l}) (x : A) (P : A -> Type@{sp ; lp}), P x -> forall y (e : eq A x y), P y :=
fun A x P px y e => J_eliminator _ x (fun y _ => P y) px y e. | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac"
] | Corelib/Init/Equality.v | J_no_dep | |
Has_J_Has_Leibniz@{s s' sp;l l' lp} {eq} {refl} (eqr : Has_J@{s s' sp;l l' lp} eq refl) : Has_Leibniz@{s s' sp;l l' lp} eq :=
fun A x P px y e => J_no_dep eqr A x P px y e. | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac"
] | Corelib/Init/Equality.v | Has_J_Has_Leibniz | |
ap[A : Type@{sa;la}] [B:Type@{sb;lb}] (f : A -> B) [x y : A] (e : eq _ x y) : eq' _ (f x) (f y) :=
leibniz A x (fun y => eq' B (f x) (f y)) (refl _ _) y e. | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac"
] | Corelib/Init/Equality.v | ap | |
sym{x y : A} (e : eq _ x y) : eq _ y x :=
leibniz _ _ (fun y => eq A y _) (refl _ _) _ e. | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac"
] | Corelib/Init/Equality.v | sym | |
Has_J_Has_J_forward@{sa se sp;la le lp} eq Has_refl
{has_J : Has_J@{sa se sp;la le lp} eq Has_refl} :
forall (A : Type@{sa ; la}) (x : A) (P : forall y : A, eq A x y -> Type@{sp ; lp}) y e,
P y e -> P x (refl A x) :=
fun A x P y e => J_eliminator _ _ (fun y e => P y e -> P _ _) (fun x => x) _ _. | Definition | Corelib | [
"Require Import Notations",
"Require Import Ltac"
] | Corelib/Init/Equality.v | Has_J_Has_J_forward |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.