Hugging Face's logo

Datasets:
phanerozoic
/
Coq-Stdpp

Tasks:
Text Generation
Feature Extraction
Modalities:
Text
Formats:
parquet
Languages:
English
Size:
1K - 10K
Tags:
theorem-proving
formal-methods
coq
stdpp
iris
Libraries:
Datasets
pandas
Polars
License:
Dataset card Data Studio Files
xet
Community
Dataset Viewer
Auto-converted to Parquet Duplicate
fact
stringlengths
9
1.52k
type
stringclasses
12 values
library
stringclasses
3 values
imports
listlengths
2
11
filename
stringclasses
54 values
symbolic_name
stringlengths
1
44
docstring
stringclasses
420 values
#[projections(primitive=yes)] Record seal {A} (f : A) := { unseal : A; seal_eq : unseal = f }.
Record
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
seal
* Sealing off definitions
TCNoBackTrack (P : Prop) := TCNoBackTrack_intro { tc_no_backtrack : P }.
Class
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
TCNoBackTrack
The type class [TCNoBackTrack P] can be used to establish [P] without ever backtracking on the instance of [P] that has been found. Backtracking may normally happen when [P] contains evars that could be instanciated in different ways depending on which instance is picked, and type class search somewhere else depends on this evar. The proper way of handling this would be by setting Coq's option `Typeclasses Unique Instances`. However, this option seems to be broken, see Coq issue #6714. See https://gitlab.mpi-sws.org/FP/iris-coq/merge_requests/112 for a rationale of this type class.
TCIf (P Q R : Prop) : Prop := | TCIf_true : P β†’ Q β†’ TCIf P Q R | TCIf_false : R β†’ TCIf P Q R.
Inductive
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
TCIf
The type class [TCNoBackTrack P] can be used to establish [P] without ever backtracking on the instance of [P] that has been found. Backtracking may normally happen when [P] contains evars that could be instanciated in different ways depending on which instance is picked, and type class search somewhere else depends on this evar. The proper way of handling this would be by setting Coq's option `Typeclasses Unique Instances`. However, this option seems to be broken, see Coq issue #6714. See https://gitlab.mpi-sws.org/FP/iris-coq/merge_requests/112 for a rationale of this type class.
Class TCIf.
Existing
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Class
null
tc_opaque {A} (x : A) : A := x.
Definition
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
tc_opaque
The constant [tc_opaque] is used to make definitions opaque for just type class search. Note that [simpl] is set up to always unfold [tc_opaque].
Class or.
Existing
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Class
null
Class and.
Existing
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Class
null
TCOr (P1 P2 : Prop) : Prop := | TCOr_l : P1 β†’ TCOr P1 P2 | TCOr_r : P2 β†’ TCOr P1 P2.
Inductive
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
TCOr
Below we define type class versions of the common logical operators. It is important to note that we duplicate the definitions, and do not declare the existing logical operators as type classes. That is, we do not say: Existing Class or. Existing Class and. If we could define the existing logical operators as classes, there is no way of disambiguating whether a premise of a lemma should be solved by type class resolution or not. These classes are useful for two purposes: writing complicated type class premises in a more concise way, and for efficiency. For example, using the [Or] class, instead of defining two instances [P β†’ Q1 β†’ R] and [P β†’ Q2 β†’ R] we could have one instance [P β†’ Or Q1 Q2 β†’ R]. When we declare the instance that way, we avoid the need to derive [P] twice.
Class TCOr.
Existing
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Class
null
Instance TCOr_l | 9.
Existing
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Instance
null
Instance TCOr_r | 10.
Existing
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Instance
null
TCAnd (P1 P2 : Prop) : Prop := TCAnd_intro : P1 β†’ P2 β†’ TCAnd P1 P2.
Inductive
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
TCAnd
null
Class TCAnd.
Existing
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Class
null
Instance TCAnd_intro.
Existing
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Instance
null
TCTrue : Prop := TCTrue_intro : TCTrue.
Inductive
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
TCTrue
null
Class TCTrue.
Existing
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Class
null
Instance TCTrue_intro.
Existing
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Instance
null
TCFalse : Prop :=.
Inductive
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
TCFalse
The class [TCFalse] is not stricly necessary as one could also use [False]. However, users might expect that TCFalse exists and if it does not, it can cause hard to diagnose bugs due to automatic generalization.
Class TCFalse.
Existing
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Class
null
TCForall {A} (P : A β†’ Prop) : list A β†’ Prop := | TCForall_nil : TCForall P [] | TCForall_cons x xs : P x β†’ TCForall P xs β†’ TCForall P (x :: xs).
Inductive
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
TCForall
null
Class TCForall.
Existing
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Class
null
Instance TCForall_nil.
Existing
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Instance
null
Instance TCForall_cons.
Existing
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Instance
null
TCForall2 {A B} (P : A β†’ B β†’ Prop) : list A β†’ list B β†’ Prop := | TCForall2_nil : TCForall2 P [] [] | TCForall2_cons x y xs ys : P x y β†’ TCForall2 P xs ys β†’ TCForall2 P (x :: xs) (y :: ys).
Inductive
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
TCForall2
The class [TCForall2 P l k] is commonly used to transform an input list [l] into an output list [k], or the converse. Therefore there are two modes, either [l] input and [k] output, or [k] input and [l] input.
Class TCForall2.
Existing
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Class
null
Instance TCForall2_nil.
Existing
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Instance
null
Instance TCForall2_cons.
Existing
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Instance
null
TCExists {A} (P : A β†’ Prop) : list A β†’ Prop := | TCExists_cons_hd x l : P x β†’ TCExists P (x :: l) | TCExists_cons_tl x l: TCExists P l β†’ TCExists P (x :: l).
Inductive
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
TCExists
null
Class TCExists.
Existing
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Class
null
Instance TCExists_cons_hd | 10.
Existing
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Instance
null
Instance TCExists_cons_tl | 20.
Existing
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Instance
null
TCElemOf {A} (x : A) : list A β†’ Prop := | TCElemOf_here xs : TCElemOf x (x :: xs) | TCElemOf_further y xs : TCElemOf x xs β†’ TCElemOf x (y :: xs).
Inductive
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
TCElemOf
null
Class TCElemOf.
Existing
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Class
null
Instance TCElemOf_here.
Existing
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Instance
null
Instance TCElemOf_further.
Existing
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Instance
null
TCEq {A} (x : A) : A β†’ Prop := TCEq_refl : TCEq x x.
Inductive
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
TCEq
The intended use of [TCEq x y] is to use [x] as input and [y] as output, but this is not enforced. We use output mode [-] (instead of [!]) for [x] to ensure that type class search succeed on goals like [TCEq (if ? then e1 else e2) ?y], see https://gitlab.mpi-sws.org/iris/iris/merge_requests/391 for a use case. Mode [-] is harmless, the only instance of [TCEq] is [TCEq_refl] below, so we cannot create loops.
Class TCEq.
Existing
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Class
null
Instance TCEq_refl.
Existing
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Instance
null
TCEq_eq {A} (x1 x2 : A) : TCEq x1 x2 ↔ x1 = x2.
Lemma
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
TCEq_eq
null
TCSimpl {A} (x x' : A) := TCSimpl_TCEq : TCEq x x'.
Class
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
TCSimpl
The [TCSimpl x y] type class is similar to [TCEq] but performs [simpl] before proving the goal by reflexivity. Similar to [TCEq], the argument [x] is the input and [y] the output. When solving [TCEq x y], the argument [x] should be a concrete term and [y] an evar for the [simpl]ed result.
TCSimpl_eq {A} (x1 x2 : A) : TCSimpl x1 x2 ↔ x1 = x2.
Lemma
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
TCSimpl_eq
null
TCDiag {A} (C : A β†’ Prop) : A β†’ A β†’ Prop := | TCDiag_diag x : C x β†’ TCDiag C x x.
Inductive
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
TCDiag
null
Class TCDiag.
Existing
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Class
null
Instance TCDiag_diag.
Existing
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Instance
null
tc_to_bool (P : Prop) {p : bool} `{TCIf P (TCEq p true) (TCEq p false)} : bool := p.
Definition
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
tc_to_bool
Given a proposition [P] that is a type class, [tc_to_bool P] will return [true] iff there is an instance of [P]. It is often useful in Ltac programming, where one can do [lazymatch tc_to_bool P with true => .. | false => .. end].
Equiv A := equiv: relation A.
Class
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Equiv
We define an operational type class for setoid equality, i.e., the "canonical" equivalence for a type. The typeclass is tied to the \equiv symbol. This is based on (Spitters/van der Weegen, 2011).
equiv_rewrite_relation `{Equiv A} : RewriteRelation (@equiv A _) | 150 := {}.
Instance
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
equiv_rewrite_relation
We instruct setoid rewriting to infer [equiv] as a relation on type [A] when needed. This allows setoid_rewrite to solve constraints of shape [Proper (eq ==> ?R) f] using [Proper (eq ==> (equiv (A:=A))) f] when an equivalence relation is available on type [A]. We put this instance at level 150 so it does not take precedence over Coq's stdlib instances, favoring inference of [eq] (all Coq functions are automatically morphisms for [eq]). We have [eq] (at 100) < [≑] (at 150) < [βŠ‘] (at 200).
LeibnizEquiv A `{Equiv A} := leibniz_equiv (x y : A) : x ≑ y β†’ x = y.
Class
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
LeibnizEquiv
The type class [LeibnizEquiv] collects setoid equalities that coincide with Leibniz equality. We provide the tactic [fold_leibniz] to transform such setoid equalities into Leibniz equalities, and [unfold_leibniz] for the reverse. Various std++ tactics assume that this class is only instantiated if [≑] is an equivalence relation.
leibniz_equiv_iff `{LeibnizEquiv A, !Reflexive (≑@{A})} (x y : A) : x ≑ y ↔ x = y.
Lemma
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
leibniz_equiv_iff
null
equivL {A} : Equiv A := (=).
Definition
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
equivL
null
equiv_default_relation `{Equiv A} : DefaultRelation (≑@{A}) | 3 := {}.
Instance
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
equiv_default_relation
The following instance forces [setoid_replace] to use setoid equality (for types that have an [Equiv] instance) rather than the standard Leibniz equality.
Decision (P : Prop) := decide : {P} + {Β¬P}.
Class
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Decision
This type class by (Spitters/van der Weegen, 2011) collects decidable propositions.
RelDecision {A B} (R : A β†’ B β†’ Prop) := decide_rel x y :: Decision (R x y).
Class
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
RelDecision
Although [RelDecision R] is just [βˆ€ x y, Decision (R x y)], we make this an explicit class instead of a notation for two reasons: - It allows us to control [Hint Mode] more precisely. In particular, if it were defined as a notation, the above [Hint Mode] for [Decision] would not prevent diverging instance search when looking for [RelDecision (@eq ?A)], which would result in it looking for [Decision (@eq ?A x y)], i.e. an instance where the head position of [Decision] is not en evar. - We use it to avoid inefficient computation due to eager evaluation of propositions by [vm_compute]. This inefficiency arises for example if [(x = y) := (f x = f y)]. Since [decide (x = y)] evaluates to [decide (f x = f y)], this would then lead to evaluation of [f x] and [f y]. Using the [RelDecision], the [f] is hidden under a lambda, which prevents unnecessary evaluation.
Inhabited (A : Type) : Type := populate { inhabitant : A }.
Class
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Inhabited
This type class collects types that are inhabited.
ProofIrrel (A : Type) : Prop := proof_irrel (x y : A) : x = y.
Class
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
ProofIrrel
This type class collects types that are proof irrelevant. That means, all elements of the type are equal. We use this notion only used for propositions, but by universe polymorphism we can generalize it.
Inj {A B} (R : relation A) (S : relation B) (f : A β†’ B) : Prop := inj x y : S (f x) (f y) β†’ R x y.
Class
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Inj
These operational type classes allow us to refer to common mathematical properties in a generic way. For example, for injectivity of [(k ++.)] it allows us to write [inj (k ++.)] instead of [app_inv_head k].
Inj2 {A B C} (R1 : relation A) (R2 : relation B) (S : relation C) (f : A β†’ B β†’ C) : Prop := inj2 x1 x2 y1 y2 : S (f x1 x2) (f y1 y2) β†’ R1 x1 y1 ∧ R2 x2 y2.
Class
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Inj2
null
Cancel {A B} (S : relation B) (f : A β†’ B) (g : B β†’ A) : Prop := cancel x : S (f (g x)) x.
Class
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Cancel
null
Surj {A B} (R : relation B) (f : A β†’ B) := surj y : βˆƒ x, R (f x) y.
Class
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Surj
null
IdemP {A} (R : relation A) (f : A β†’ A β†’ A) : Prop := idemp x : R (f x x) x.
Class
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
IdemP
null
Comm {A B} (R : relation A) (f : B β†’ B β†’ A) : Prop := comm x y : R (f x y) (f y x).
Class
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Comm
null
LeftId {A} (R : relation A) (i : A) (f : A β†’ A β†’ A) : Prop := left_id x : R (f i x) x.
Class
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
LeftId
null
RightId {A} (R : relation A) (i : A) (f : A β†’ A β†’ A) : Prop := right_id x : R (f x i) x.
Class
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
RightId
null
Assoc {A} (R : relation A) (f : A β†’ A β†’ A) : Prop := assoc x y z : R (f x (f y z)) (f (f x y) z).
Class
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Assoc
null
LeftAbsorb {A} (R : relation A) (i : A) (f : A β†’ A β†’ A) : Prop := left_absorb x : R (f i x) i.
Class
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
LeftAbsorb
null
RightAbsorb {A} (R : relation A) (i : A) (f : A β†’ A β†’ A) : Prop := right_absorb x : R (f x i) i.
Class
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
RightAbsorb
null
AntiSymm {A} (R S : relation A) : Prop := anti_symm x y : S x y β†’ S y x β†’ R x y.
Class
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
AntiSymm
null
Total {A} (R : relation A) := total x y : R x y ∨ R y x.
Class
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Total
null
Trichotomy {A} (R : relation A) := trichotomy x y : R x y ∨ x = y ∨ R y x.
Class
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
Trichotomy
null
TrichotomyT {A} (R : relation A) := trichotomyT x y : {R x y} + {x = y} + {R y x}.
Class
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
TrichotomyT
null
involutive {A} {R : relation A} (f : A β†’ A) `{Involutive R f} x : R (f (f x)) x.
Lemma
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
involutive
null
not_symmetry `{R : relation A, !Symmetric R} x y : Β¬R x y β†’ Β¬R y x.
Lemma
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
not_symmetry
null
symmetry_iff `(R : relation A) `{!Symmetric R} x y : R x y ↔ R y x.
Lemma
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
symmetry_iff
null
not_inj `{Inj A B R R' f} x y : Β¬R x y β†’ Β¬R' (f x) (f y).
Lemma
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
not_inj
null
not_inj2_1 `{Inj2 A B C R R' R'' f} x1 x2 y1 y2 : Β¬R x1 x2 β†’ Β¬R'' (f x1 y1) (f x2 y2).
Lemma
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
not_inj2_1
null
not_inj2_2 `{Inj2 A B C R R' R'' f} x1 x2 y1 y2 : Β¬R' y1 y2 β†’ Β¬R'' (f x1 y1) (f x2 y2).
Lemma
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
not_inj2_2
null
inj_iff {A B} {R : relation A} {S : relation B} (f : A β†’ B) `{!Inj R S f} `{!Proper (R ==> S) f} x y : S (f x) (f y) ↔ R x y.
Lemma
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
inj_iff
null
inj2_inj_1 `{Inj2 A B C R1 R2 R3 f} y : Inj R1 R3 (Ξ» x, f x y).
Instance
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
inj2_inj_1
null
inj2_inj_2 `{Inj2 A B C R1 R2 R3 f} x : Inj R2 R3 (f x).
Instance
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
inj2_inj_2
null
cancel_inj `{Cancel A B R1 f g, !Equivalence R1, !Proper (R2 ==> R1) f} : Inj R1 R2 g.
Lemma
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
cancel_inj
Smart constructors for [Inj] and [Surj] based on [Cancel]. These are not instances because they will blow-up the search space due to diamonds: in every node of the search tree for [Inj] or [Surj] of composed functions these instances could be applied. Note that [f] and [g] do not need to be given, these are infered using [Cancel].
cancel_surj `{Cancel A B R1 f g} : Surj R1 f.
Lemma
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
cancel_surj
null
idemp_L {A} f `{!@IdemP A (=) f} x : f x x = x.
Lemma
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
idemp_L
The following lemmas are specific versions of the projections of the above type classes for Leibniz equality. These lemmas allow us to enforce Coq not to use the setoid rewriting mechanism.
comm_L {A B} f `{!@Comm A B (=) f} x y : f x y = f y x.
Lemma
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
comm_L
null
left_id_L {A} i f `{!@LeftId A (=) i f} x : f i x = x.
Lemma
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
left_id_L
null
right_id_L {A} i f `{!@RightId A (=) i f} x : f x i = x.
Lemma
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
right_id_L
null
assoc_L {A} f `{!@Assoc A (=) f} x y z : f x (f y z) = f (f x y) z.
Lemma
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
assoc_L
null
left_absorb_L {A} i f `{!@LeftAbsorb A (=) i f} x : f i x = i.
Lemma
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
left_absorb_L
null
right_absorb_L {A} i f `{!@RightAbsorb A (=) i f} x : f x i = i.
Lemma
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
right_absorb_L
null
strict {A} (R : relation A) : relation A := λ X Y, R X Y ∧ ¬R Y X.
Definition
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
strict
The classes [PreOrder], [PartialOrder], and [TotalOrder] use an arbitrary relation [R] instead of [βŠ†] to support multiple orders on the same type.
PartialOrder {A} (R : relation A) : Prop := { partial_order_pre :: PreOrder R; partial_order_anti_symm :: AntiSymm (=) R }.
Class
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
PartialOrder
null
TotalOrder {A} (R : relation A) : Prop := { total_order_partial :: PartialOrder R; total_order_trichotomy :: Trichotomy (strict R) }.
Class
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
TotalOrder
null
prop_inhabited : Inhabited Prop := populate True.
Instance
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
prop_inhabited
* Logic
or_l P Q : Β¬Q β†’ P ∨ Q ↔ P.
Lemma
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
or_l
null
or_r P Q : Β¬P β†’ P ∨ Q ↔ Q.
Lemma
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
or_r
null
and_wlog_l (P Q : Prop) : (Q β†’ P) β†’ Q β†’ (P ∧ Q).
Lemma
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
and_wlog_l
null
and_wlog_r (P Q : Prop) : P β†’ (P β†’ Q) β†’ (P ∧ Q).
Lemma
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
and_wlog_r
null
impl_trans (P Q R : Prop) : (P β†’ Q) β†’ (Q β†’ R) β†’ (P β†’ R).
Lemma
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
impl_trans
null
forall_proper {A} (P Q : A β†’ Prop) : (βˆ€ x, P x ↔ Q x) β†’ (βˆ€ x, P x) ↔ (βˆ€ x, Q x).
Lemma
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
forall_proper
null
exist_proper {A} (P Q : A β†’ Prop) : (βˆ€ x, P x ↔ Q x) β†’ (βˆƒ x, P x) ↔ (βˆƒ x, Q x).
Lemma
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
exist_proper
null
eq_comm {A} : Comm (↔) (=@{A}).
Instance
stdpp
[ "Stdlib.Morphisms", "Stdlib.RelationClasses", "Stdlib.List", "Stdlib.Bool", "Stdlib.Setoid", "Stdlib.Peano", "Stdlib.Utf8", "Stdlib.Permutation", "Stdlib.Program.Basics", "Stdlib.Program.Syntax", "stdpp.options" ]
stdpp/base.v
eq_comm
null
End of preview. Expand in Data Studio

Coq-Stdpp

Structured dataset of formalizations from the std++ library (used by Iris).

Schema

Column Type Description
fact string Full declaration (name, signature, body)
type string Lemma, Definition, Instance, Class, etc.
library string Sub-library (stdpp, stdpp_bitvector, stdpp_unstable)
imports list Import statements
filename string Source file path
symbolic_name string Declaration identifier
docstring string Documentation comment (9% coverage)

Statistics

By Type

Type Count
Lemma 3,374
Instance 1,000
Definition 311
Class 103
Fixpoint 93
Inductive 43
Existing 30
Record 18
Other 10

Example Entry

Use Cases

  • Retrieval / RAG for Coq/Iris theorem proving
  • Separation logic research
  • Training embeddings for formal mathematics

Related Datasets

Citation

Downloads last month
18
Source:
iris/stdpp
Entries:
4,982
Files processed:
59
License:
BSD 3-Clause
Size of downloaded dataset files:
272 kB
Size of the auto-converted Parquet files:
272 kB
Number of rows:
4,982

Collection including phanerozoic/Coq-Stdpp