phanerozoic/Coq-Stdpp · Datasets at Hugging Face

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

#[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