statement stringlengths 1 1.39k | proof stringlengths 0 4.58k | type stringclasses 21
values | symbolic_name stringlengths 1 49 | library stringclasses 18
values | filename stringclasses 100
values | imports listlengths 0 26 | deps listlengths 0 23 | docstring stringlengths 0 2.01k | source_url stringclasses 1
value | commit stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|
collect | := @collect. | Definition | collect | doc | doc/DocumentationCheck.v | [
"mathcomp",
"ssreflect",
"ssrfun",
"ssrbool",
"Coq",
"Relations",
"ZArith",
"Strings.Ascii",
"Strings.String",
"QuickChick",
"LazyList",
"doc",
"QuickChickInterface",
"QcDefaultNotation"
] | [] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
tag | := @tag. | Definition | tag | doc | doc/DocumentationCheck.v | [
"mathcomp",
"ssreflect",
"ssrfun",
"ssrbool",
"Coq",
"Relations",
"ZArith",
"Strings.Ascii",
"Strings.String",
"QuickChick",
"LazyList",
"doc",
"QuickChickInterface",
"QcDefaultNotation"
] | [] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
conjoin | := @conjoin. | Definition | conjoin | doc | doc/DocumentationCheck.v | [
"mathcomp",
"ssreflect",
"ssrfun",
"ssrbool",
"Coq",
"Relations",
"ZArith",
"Strings.Ascii",
"Strings.String",
"QuickChick",
"LazyList",
"doc",
"QuickChickInterface",
"QcDefaultNotation"
] | [] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
disjoin | := @disjoin. | Definition | disjoin | doc | doc/DocumentationCheck.v | [
"mathcomp",
"ssreflect",
"ssrfun",
"ssrbool",
"Coq",
"Relations",
"ZArith",
"Strings.Ascii",
"Strings.String",
"QuickChick",
"LazyList",
"doc",
"QuickChickInterface",
"QcDefaultNotation"
] | [] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
implication | := @implication. | Definition | implication | doc | doc/DocumentationCheck.v | [
"mathcomp",
"ssreflect",
"ssrfun",
"ssrbool",
"Coq",
"Relations",
"ZArith",
"Strings.Ascii",
"Strings.String",
"QuickChick",
"LazyList",
"doc",
"QuickChickInterface",
"QcDefaultNotation"
] | [] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
"x ==> y" | :=
(implication x y) (at level 55, right associativity)
: Checker_scope. | Notation | x ==> y | doc | doc/DocumentationCheck.v | [
"mathcomp",
"ssreflect",
"ssrfun",
"ssrbool",
"Coq",
"Relations",
"ZArith",
"Strings.Ascii",
"Strings.String",
"QuickChick",
"LazyList",
"doc",
"QuickChickInterface",
"QcDefaultNotation"
] | [
"implication"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
testDec | := @testDec . | Definition | testDec | doc | doc/DocumentationCheck.v | [
"mathcomp",
"ssreflect",
"ssrfun",
"ssrbool",
"Coq",
"Relations",
"ZArith",
"Strings.Ascii",
"Strings.String",
"QuickChick",
"LazyList",
"doc",
"QuickChickInterface",
"QcDefaultNotation"
] | [] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
Dec_neg | := @Dec_neg . | Definition | Dec_neg | doc | doc/DocumentationCheck.v | [
"mathcomp",
"ssreflect",
"ssrfun",
"ssrbool",
"Coq",
"Relations",
"ZArith",
"Strings.Ascii",
"Strings.String",
"QuickChick",
"LazyList",
"doc",
"QuickChickInterface",
"QcDefaultNotation"
] | [] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
Dec_conj | := @Dec_conj . | Definition | Dec_conj | doc | doc/DocumentationCheck.v | [
"mathcomp",
"ssreflect",
"ssrfun",
"ssrbool",
"Coq",
"Relations",
"ZArith",
"Strings.Ascii",
"Strings.String",
"QuickChick",
"LazyList",
"doc",
"QuickChickInterface",
"QcDefaultNotation"
] | [] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
Dec_disj | := @Dec_disj . | Definition | Dec_disj | doc | doc/DocumentationCheck.v | [
"mathcomp",
"ssreflect",
"ssrfun",
"ssrbool",
"Coq",
"Relations",
"ZArith",
"Strings.Ascii",
"Strings.String",
"QuickChick",
"LazyList",
"doc",
"QuickChickInterface",
"QcDefaultNotation"
] | [] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
"P '?'" | := (match (@dec P _) with
| left _ => true
| right _ => false
end) (at level 100). | Notation | P '?' | doc | doc/DocumentationCheck.v | [
"mathcomp",
"ssreflect",
"ssrfun",
"ssrbool",
"Coq",
"Relations",
"ZArith",
"Strings.Ascii",
"Strings.String",
"QuickChick",
"LazyList",
"doc",
"QuickChickInterface",
"QcDefaultNotation"
] | [] | Convenient notation. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 |
dec_if_dec_eq | := @dec_if_dec_eq. | Definition | dec_if_dec_eq | doc | doc/DocumentationCheck.v | [
"mathcomp",
"ssreflect",
"ssrfun",
"ssrbool",
"Coq",
"Relations",
"ZArith",
"Strings.Ascii",
"Strings.String",
"QuickChick",
"LazyList",
"doc",
"QuickChickInterface",
"QcDefaultNotation"
] | [] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
Dec_Eq_implies_DecEq | := @Dec_Eq_implies_DecEq. | Definition | Dec_Eq_implies_DecEq | doc | doc/DocumentationCheck.v | [
"mathcomp",
"ssreflect",
"ssrfun",
"ssrbool",
"Coq",
"Relations",
"ZArith",
"Strings.Ascii",
"Strings.String",
"QuickChick",
"LazyList",
"doc",
"QuickChickInterface",
"QcDefaultNotation"
] | [] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
Dec_eq_unit | := @Dec_eq_unit. | Definition | Dec_eq_unit | doc | doc/DocumentationCheck.v | [
"mathcomp",
"ssreflect",
"ssrfun",
"ssrbool",
"Coq",
"Relations",
"ZArith",
"Strings.Ascii",
"Strings.String",
"QuickChick",
"LazyList",
"doc",
"QuickChickInterface",
"QcDefaultNotation"
] | [] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
Dec_eq_bool | := @Dec_eq_bool. | Definition | Dec_eq_bool | doc | doc/DocumentationCheck.v | [
"mathcomp",
"ssreflect",
"ssrfun",
"ssrbool",
"Coq",
"Relations",
"ZArith",
"Strings.Ascii",
"Strings.String",
"QuickChick",
"LazyList",
"doc",
"QuickChickInterface",
"QcDefaultNotation"
] | [] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
Dec_eq_nat | := @Dec_eq_nat. | Definition | Dec_eq_nat | doc | doc/DocumentationCheck.v | [
"mathcomp",
"ssreflect",
"ssrfun",
"ssrbool",
"Coq",
"Relations",
"ZArith",
"Strings.Ascii",
"Strings.String",
"QuickChick",
"LazyList",
"doc",
"QuickChickInterface",
"QcDefaultNotation"
] | [] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
Dec_eq_Z | := @Dec_eq_Z. | Definition | Dec_eq_Z | doc | doc/DocumentationCheck.v | [
"mathcomp",
"ssreflect",
"ssrfun",
"ssrbool",
"Coq",
"Relations",
"ZArith",
"Strings.Ascii",
"Strings.String",
"QuickChick",
"LazyList",
"doc",
"QuickChickInterface",
"QcDefaultNotation"
] | [] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
Dec_eq_N | := @Dec_eq_N. | Definition | Dec_eq_N | doc | doc/DocumentationCheck.v | [
"mathcomp",
"ssreflect",
"ssrfun",
"ssrbool",
"Coq",
"Relations",
"ZArith",
"Strings.Ascii",
"Strings.String",
"QuickChick",
"LazyList",
"doc",
"QuickChickInterface",
"QcDefaultNotation"
] | [] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
Dec_eq_opt | := @Dec_eq_opt. | Definition | Dec_eq_opt | doc | doc/DocumentationCheck.v | [
"mathcomp",
"ssreflect",
"ssrfun",
"ssrbool",
"Coq",
"Relations",
"ZArith",
"Strings.Ascii",
"Strings.String",
"QuickChick",
"LazyList",
"doc",
"QuickChickInterface",
"QcDefaultNotation"
] | [] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
Dec_eq_prod | := @Dec_eq_prod. | Definition | Dec_eq_prod | doc | doc/DocumentationCheck.v | [
"mathcomp",
"ssreflect",
"ssrfun",
"ssrbool",
"Coq",
"Relations",
"ZArith",
"Strings.Ascii",
"Strings.String",
"QuickChick",
"LazyList",
"doc",
"QuickChickInterface",
"QcDefaultNotation"
] | [] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
Dec_eq_sum | := @Dec_eq_sum. | Definition | Dec_eq_sum | doc | doc/DocumentationCheck.v | [
"mathcomp",
"ssreflect",
"ssrfun",
"ssrbool",
"Coq",
"Relations",
"ZArith",
"Strings.Ascii",
"Strings.String",
"QuickChick",
"LazyList",
"doc",
"QuickChickInterface",
"QcDefaultNotation"
] | [] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
Dec_eq_list | := @Dec_eq_list. | Definition | Dec_eq_list | doc | doc/DocumentationCheck.v | [
"mathcomp",
"ssreflect",
"ssrfun",
"ssrbool",
"Coq",
"Relations",
"ZArith",
"Strings.Ascii",
"Strings.String",
"QuickChick",
"LazyList",
"doc",
"QuickChickInterface",
"QcDefaultNotation"
] | [] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
Dec_eq_ascii | := @Dec_eq_ascii. | Definition | Dec_eq_ascii | doc | doc/DocumentationCheck.v | [
"mathcomp",
"ssreflect",
"ssrfun",
"ssrbool",
"Coq",
"Relations",
"ZArith",
"Strings.Ascii",
"Strings.String",
"QuickChick",
"LazyList",
"doc",
"QuickChickInterface",
"QcDefaultNotation"
] | [] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
Dec_eq_string | := @Dec_eq_string. | Definition | Dec_eq_string | doc | doc/DocumentationCheck.v | [
"mathcomp",
"ssreflect",
"ssrfun",
"ssrbool",
"Coq",
"Relations",
"ZArith",
"Strings.Ascii",
"Strings.String",
"QuickChick",
"LazyList",
"doc",
"QuickChickInterface",
"QcDefaultNotation"
] | [] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
Args | :=
MkArgs
{
(* Re-execute a test. *)
(* Default: None *)
replay : option (RandomSeed * nat);
(* Maximum number of successful tests to run. *)
(* Default: 10000 *)
maxSuccess : nat;
(* Maximum number of discards to accept. *)
(* Default: 20000... | Record | Args | doc | doc/DocumentationCheck.v | [
"mathcomp",
"ssreflect",
"ssrfun",
"ssrbool",
"Coq",
"Relations",
"ZArith",
"Strings.Ascii",
"Strings.String",
"QuickChick",
"LazyList",
"doc",
"QuickChickInterface",
"QcDefaultNotation"
] | [
"RandomSeed",
"nat"
] | Arguments to customize execution. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 |
nl : string | := String (ascii_of_nat 10) EmptyString. | Definition | nl | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"string"
] | When defining [Show] instance for your own datatypes, you sometimes need to
start a new line for better printing. [nl] is a shorthand for it. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 |
RandomSeed : Type. | Parameter | RandomSeed | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [] | A [RandomSeed] represents a particular starting point in a
pseudo-random sequence. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
G : Type -> Type. | Parameter | G | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [] | [G A] is the type of random generators for type [A]. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
run : forall {A : Type}, G A -> nat -> RandomSeed -> A. | Parameter | run | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"RandomSeed",
"nat"
] | Run a generator with a size parameter (a natural number denoting
the maximum depth of the generated A) and a random seed. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
bindGenOpt : forall {A B : Type},
G (option A) -> (A -> G (option B)) -> G (option B). | Parameter | bindGenOpt | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [] | A variant of bind for the [(G (option --))] monad. Useful for
chaining generators that can fail / backtrack. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
listOf : forall {A : Type}, G A -> G (list A). | Parameter | listOf | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [] | The [listOf] and [vectorOf] combinators construct generators for
[list A], provided a generator [g] for type [A]: [listOf g] yields
an arbitrary-sized list (which might be empty), while [vectorOf n
g] yields a list of fixed size [n]. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
vectorOf : forall {A : Type}, nat -> G A -> G (list A). | Parameter | vectorOf | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"nat"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | ||
elems_ : forall {A : Type}, A -> list A -> G A. | Parameter | elems_ | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [] | [elems_ a l] constructs a generator from a list [l] and a
default element [a]. If [l] is non-empty, the generator picks an
element from [l] uniformly; otherwise it always yields [a]. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
oneOf_ : forall {A : Type}, G A -> list (G A) -> G A. | Parameter | oneOf_ | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [] | Similar to [elems_], instead of choosing from a list of [A]s,
[oneOf_ g l] returns [g] if [l] is empty; otherwise it uniformly
picks a generator for [A] in [l]. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
freq_ :
forall {A : Type}, G A -> list (nat * G A) -> G A. | Parameter | freq_ | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"nat"
] | We can also choose generators with distributions other than the
uniform one. [freq_ g l] returns [g] if [l] is empty;
otherwise it chooses a generator from [l], where the first field
indicates the chance that the second field is chosen. For example,
[freq_ z [(2, x); (3, y)]] has 40%% probability of cho... | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
backtrack :
forall {A : Type}, list (nat * G (option A)) -> G (option A). | Parameter | backtrack | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"nat"
] | Try all generators until one returns a [Some] value or all failed once with
[None]. The generators are picked at random according to their weights
(like [frequency]), and each one is run at most once. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
sized : forall {A: Type}, (nat -> G A) -> G A. | Parameter | sized | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"nat"
] | Internally, the G monad hides a [size] parameter that can be accessed by
generators. The [sized] combinator provides such access. The [resize]
combinator sets it. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
resize : forall {A: Type}, nat -> G A -> G A. | Parameter | resize | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"nat"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | ||
suchThatMaybe :
forall {A : Type}, G A -> (A -> bool) -> G (option A). | Parameter | suchThatMaybe | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [] | Generate-and-test approach to generate data with preconditions. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
suchThatMaybeOpt :
forall {A : Type}, G (option A) -> (A -> bool) -> G (option A). | Parameter | suchThatMaybeOpt | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | ||
" 'elems' [ x ] " | :=
(elems_ x (cons x nil)) : qc_scope. | Notation | 'elems' [ x ] | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"elems_"
] | [elems] is a shorthand for [elems_] without a default argument. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 |
" 'elems' [ x ; y ] " | :=
(elems_ x (cons x (cons y nil))) : qc_scope. | Notation | 'elems' [ x ; y ] | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"elems_"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
" 'elems' [ x ; y ; .. ; z ] " | :=
(elems_ x (cons x (cons y .. (cons z nil) ..))) : qc_scope. | Notation | 'elems' [ x ; y ; .. ; z ] | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"elems_"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
" 'elems' ( x ;; l ) " | :=
(elems_ x (cons x l)) (at level 1, no associativity) : qc_scope. | Notation | 'elems' ( x ;; l ) | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"elems_"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
" 'oneOf' [ x ] " | :=
(oneOf_ x (cons x nil)) : qc_scope. | Notation | 'oneOf' [ x ] | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"oneOf_"
] | [oneOf] is a shorthand for [oneOf_] without a default argument. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 |
" 'oneOf' [ x ; y ] " | :=
(oneOf_ x (cons x (cons y nil))) : qc_scope. | Notation | 'oneOf' [ x ; y ] | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"oneOf_"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
" 'oneOf' [ x ; y ; .. ; z ] " | :=
(oneOf_ x (cons x (cons y .. (cons z nil) ..))) : qc_scope. | Notation | 'oneOf' [ x ; y ; .. ; z ] | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"oneOf_"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
" 'oneOf' ( x ;; l ) " | :=
(oneOf_ x (cons x l)) (at level 1, no associativity) : qc_scope. | Notation | 'oneOf' ( x ;; l ) | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"oneOf_"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
" 'freq' [ x ] " | :=
(freq_ x (cons x nil)) : qc_scope. | Notation | 'freq' [ x ] | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"freq_"
] | [freq] is a shorthand for [freq_] without a default argument. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 |
" 'freq' [ ( n , x ) ; y ] " | :=
(freq_ x (cons (n, x) (cons y nil))) : qc_scope. | Notation | 'freq' [ ( n , x ) ; y ] | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"freq_"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
" 'freq' [ ( n , x ) ; y ; .. ; z ] " | :=
(freq_ x (cons (n, x) (cons y .. (cons z nil) ..))) : qc_scope. | Notation | 'freq' [ ( n , x ) ; y ; .. ; z ] | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"freq_"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
" 'freq' ( ( n , x ) ;; l ) " | :=
(freq_ x (cons (n, x) l)) (at level 1, no associativity) : qc_scope. | Notation | 'freq' ( ( n , x ) ;; l ) | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"freq_"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
choose :
forall {A : Type} `{ChoosableFromInterval A}, (A * A) -> G A. | Parameter | choose | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"ChoosableFromInterval"
] | [choose l r] generates a value between [l] and [r], inclusive the two
extremes. It causes a runtime error if [r < l]. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
"'genSizedST' x" | := ((@arbitrarySizeST _ x _)) (at level 10). | Notation | 'genSizedST' x | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [] | So, for example, if you have a typing relation
[has_type : exp -> type -> Prop] for some language, you could,
given some type [T] as input, write (or derive as we will see later on)
an instance of [GenSizedSuchThat (fun e => has_type e T)], that produces
an expression of with type [T].
Cal... | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 |
"'genST' x" | := ((@arbitraryST _ x _)) (at level 10). | Notation | 'genST' x | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
Checker : Type. | Parameter | Checker | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [] | [Checker] is the opaque type of QuickChick properties. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
forAll :
forall {A prop : Type} `{Checkable prop} `{Show A}
(gen : G A) (pf : A -> prop), Checker. | Parameter | forAll | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"Checkable",
"Checker",
"Show",
"gen",
"prop"
] | Given a generator for showable [A]s, construct a [Checker]. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
forAllShrink :
forall {A prop : Type} `{Checkable prop} `{Show A}
(gen : G A) (shrinker : A -> list A) (pf : A -> prop), Checker. | Parameter | forAllShrink | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"Checkable",
"Checker",
"Show",
"gen",
"prop"
] | Given a generator and a shrinker for showable [A]s, construct a
[Checker]. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
whenFail :
forall {prop : Type} `{Checkable prop} (str : string), prop -> Checker. | Parameter | whenFail | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"Checkable",
"Checker",
"prop",
"string"
] | Print a specific string if the property fails. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
expectFailure :
forall {prop: Type} `{Checkable prop} (p: prop), Checker. | Parameter | expectFailure | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"Checkable",
"Checker",
"prop"
] | SOONER: I think I need help with the phrasing here. What I mean is
QuickChick will run its default number of tests (whether that is
100 or 10000000 doesn't matter). If all of those 100 or 10000000
tests succeed, then an [expectFailure property] is considered to
fail because a failure was expected but not fo... | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
collect :
forall {A prop : Type} `{Show A} `{Checkable prop} (x : A),
prop -> Checker. | Parameter | collect | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"Checkable",
"Checker",
"Show",
"prop"
] | Collect statistics across all tests. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
tag :
forall {prop : Type} `{Checkable prop} (t : string), prop -> Checker. | Parameter | tag | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"Checkable",
"Checker",
"prop",
"string"
] | SOONER: Explain better. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
conjoin : forall (l : list Checker), Checker. | Parameter | conjoin | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"Checker"
] | SOONER: BCP: I think keeping is best. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
disjoin : forall (l : list Checker), Checker. | Parameter | disjoin | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"Checker"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | ||
implication :
forall {prop : Type} `{Checkable prop} (b : bool) (p : prop), Checker. | Parameter | implication | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"Checkable",
"Checker",
"prop"
] | Define a checker for a conditional property. Invalid generated
inputs (ones for which the antecedent fails) are discarded. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
"x ==> y" | :=
(implication x y) (at level 55, right associativity)
: Checker_scope. | Notation | x ==> y | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"implication"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
"P '?'" | := (match (@dec P _) with
| left _ => true
| right _ => false
end) (at level 100). | Notation | P '?' | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [] | A convenient notation for coercing a decidable proposition to a [bool]. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 |
Args | :=
MkArgs
{
(* Re-execute a test. *)
(* Default: None *)
replay : option (RandomSeed * nat);
(* Maximum number of successful tests to run. *)
(* Default: 10000 *)
maxSuccess : nat;
(* Maximum number of discards to accept. *)
(* Default: 20000 *)
maxDiscard... | Record | Args | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"RandomSeed",
"nat"
] | QuickChick uses arguments to customize execution. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 |
semGen : forall {A : Type} (g : G A), set A. | Parameter | semGen | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"set"
] | The semantics of a generator is its set of possible outcomes. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
semGenSize : forall {A : Type} (g : G A) (size : nat), set A. | Parameter | semGenSize | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"nat",
"set",
"size"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | ||
bindGen' : forall {A B : Type} (g : G A),
(forall (a : A), (a \in semGen g) -> G B) -> G B. | Parameter | bindGen' | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"semGen"
] | A variant of monadic bind where the continuation also takes a
_proof_ that the value received is within the set of outcomes of
the first generator. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
forAllProof :
forall {A prop : Type} `{Checkable prop} `{Show A}
(gen : G A) (pf : forall (x : A), semGen gen x -> prop), Checker. | Parameter | forAllProof | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"Checkable",
"Checker",
"Show",
"gen",
"prop",
"semGen"
] | A variant of [forAll] that provides evidence that the generated
values are members of the semantics of the generator. (Such evidence
can be useful when constructing dependently typed data, such as
bounded integers.) | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
"'do!' X <- A ; B" | :=
(bindGen A (fun X => B))
(at level 200, X name, A at level 100, B at level 200). | Notation | 'do!' X <- A ; B | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"bindGen"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
"'do\'' X <- A ; B" | :=
(bindGen' A (fun X H => B))
(at level 200, X name, A at level 100, B at level 200). | Notation | 'do\'' X <- A ; B | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"bindGen'"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
"'doM!' X <- A ; B" | :=
(bindGenOpt A (fun X => B))
(at level 200, X name, A at level 100, B at level 200). | Notation | 'doM!' X <- A ; B | doc | doc/QuickChickInterface.v | [
"QuickChick",
"ZArith",
"Strings.Ascii",
"Strings.String",
"ExtLib.Structures",
"Functor",
"Applicative",
"QcDefaultNotation",
"Proofs"
] | [
"bindGenOpt"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
plus' : nat -> nat -> nat. | Parameter | plus' | examples.c-mutation.t | examples/c-mutation.t/plus.v | [
"QuickChick"
] | [
"nat"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | ||
plus_prop x y | :=
plus' x y = x + y?. | Definition | plus_prop | examples.c-mutation.t | examples/c-mutation.t/plus.v | [
"QuickChick"
] | [
"plus'"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
square_of_equiv : nat -> nat -> Prop | :=
| sq' : forall n m,
mult n n = m -> square_of_equiv n m. | Inductive | square_of_equiv | examples.deriving-tests | examples/deriving-tests/function.v | [
"QuickChick",
"Nat"
] | [
"mult",
"nat"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
equiv_1 :
@decOpt (square_of_equiv 2 4) _ 42 = Some true. | Proof. reflexivity. Qed. | Example | equiv_1 | examples.deriving-tests | examples/deriving-tests/function.v | [
"QuickChick",
"Nat"
] | [
"square_of_equiv"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
equiv_2 :
@decOpt (square_of_equiv 2 5) _ 42 = Some false. | Proof. reflexivity. Qed. | Example | equiv_2 | examples.deriving-tests | examples/deriving-tests/function.v | [
"QuickChick",
"Nat"
] | [
"square_of_equiv"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
square_of : nat -> nat -> Prop | :=
| sq : forall n, square_of n (n * n). | Inductive | square_of | examples.deriving-tests | examples/deriving-tests/function.v | [
"QuickChick",
"Nat"
] | [
"nat"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
sq_1 :
@decOpt (square_of 2 4) _ 42 = Some true. | Proof. reflexivity. Qed. | Example | sq_1 | examples.deriving-tests | examples/deriving-tests/function.v | [
"QuickChick",
"Nat"
] | [
"square_of"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
sq_2 :
@decOpt (square_of 2 5) _ 42 = Some false. | Proof. reflexivity. Qed. | Example | sq_2 | examples.deriving-tests | examples/deriving-tests/function.v | [
"QuickChick",
"Nat"
] | [
"square_of"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
correct_prod : (prod nat bool) -> Prop | :=
| CorrectR1 : forall (p : prod nat bool) (n : nat), correct_prod (pair n (snd p)). | Inductive | correct_prod | examples.deriving-tests | examples/deriving-tests/function.v | [
"QuickChick",
"Nat"
] | [
"nat",
"snd"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
merge {X:Type} : list X -> list X -> list X -> Prop | :=
| merge_empty :
merge nil nil nil
| merge_left : forall l1 l2 l3 x,
merge l1 l2 l3 ->
merge (x::l1) l2 (x::l3)
| merge_right : forall l1 l2 l3 x,
merge l1 l2 l3 ->
merge l1 (x::l2) (x::l3). | Inductive | merge | examples.deriving-tests | examples/deriving-tests/in.v | [
"QuickChick"
] | [] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
In' {A:Type} : A -> list A -> Prop | :=
| In_hd :
forall x l, In' x (cons x l)
| In_tl :
forall x y l, In' x l -> In' x (cons y l). | Inductive | In' | examples.deriving-tests | examples/deriving-tests/in.v | [
"QuickChick"
] | [] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
In' (A:Type) : A -> list A -> Prop | :=
| In_hd :
forall x l, In' A x (cons x l)
| In_tl :
forall x y l, In' A x l -> In' A x (cons y l). | Inductive | In' | examples.deriving-tests | examples/deriving-tests/nodup.v | [
"QuickChick"
] | [] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
NoDup {A:Type} : list A -> Prop | :=
| NoDup_nil : NoDup nil
| NoDup_cons :
forall a l,
~ In' A a l ->
NoDup l ->
NoDup (a :: l). | Inductive | NoDup | examples.deriving-tests | examples/deriving-tests/nodup.v | [
"QuickChick"
] | [
"In'"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
repeats {X:Type} : list X -> Prop | :=
| rep_here : forall a l, In' X a l -> repeats (a::l)
| rep_later : forall a l, repeats l -> repeats (a::l). | Inductive | repeats | examples.deriving-tests | examples/deriving-tests/nodup.v | [
"QuickChick"
] | [
"In'"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
nostutter {X:Type} : list X -> Prop | :=
| nostutter0: nostutter nil
| nostutter1 n : nostutter (n::nil)
| nostutter2 a b r : a <> b -> nostutter (b::r) -> nostutter (a::b::r). | Inductive | nostutter | examples.deriving-tests | examples/deriving-tests/nostutter.v | [
"QuickChick"
] | [] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
subst (y : var) (e1 : term) (e2 : term) : term | :=
match e2 with
| Const n => Const n
| Id x =>
if eq_nat_dec x y then e1 else e2
| App e e' =>
App (subst y e1 e) (subst y e1 e')
| Abs t e =>
Abs t (subst (S y) e1 e)
end. | Fixpoint | subst | examples.deriving-tests | examples/deriving-tests/stlc.v | [
"mathcomp",
"ssreflect",
"ssrbool",
"eqtype",
"Arith",
"List",
"String",
"Lia",
"QuickChick",
"ListNotations"
] | [
"term",
"var"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
preservation' (e : term) (t: type) : Checker | :=
match step e with
| Some e' => typing nil e' t ?? 10
| None => checker true
end. | Definition | preservation' | examples.deriving-tests | examples/deriving-tests/stlc.v | [
"mathcomp",
"ssreflect",
"ssrbool",
"eqtype",
"Arith",
"List",
"String",
"Lia",
"QuickChick",
"ListNotations"
] | [
"Checker",
"step",
"term",
"type",
"typing"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
preservation_prop (c : term -> type -> Checker) | :=
forAll (@arbitrary type _) (fun t =>
forAllMaybe ((genST (fun e => typing nil e t))) (fun e =>
c e t)). | Definition | preservation_prop | examples.deriving-tests | examples/deriving-tests/stlc.v | [
"mathcomp",
"ssreflect",
"ssrbool",
"eqtype",
"Arith",
"List",
"String",
"Lia",
"QuickChick",
"ListNotations"
] | [
"Checker",
"forAll",
"forAllMaybe",
"term",
"type",
"typing"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
good_Z : Z -> Prop | :=
| GoodZ0 : good_Z 0
| GoodZ1 : good_Z 1. | Inductive | good_Z | examples.ifc-basic | examples/ifc-basic/DerivedGen.v | [
"QuickChick",
"ZArith",
"List",
"ListNotations",
"QuickChick.ifcbasic",
"Machine",
"Printing",
"Generation"
] | [] | Definition gen_Z := choose (0,1). | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 |
good_atom : Atom -> Prop | :=
| GoodAtom : forall z l, good_Z z -> good_atom (Atm z l). | Inductive | good_atom | examples.ifc-basic | examples/ifc-basic/DerivedGen.v | [
"QuickChick",
"ZArith",
"List",
"ListNotations",
"QuickChick.ifcbasic",
"Machine",
"Printing",
"Generation"
] | [
"Atom",
"good_Z"
] | Definition gen_atom := liftGen2 Atm gen_Z gen_label. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 |
good_mem : Mem -> Prop | :=
| GoodMem : forall a1 a2, good_atom a1 -> good_atom a2 -> good_mem [a1 ; a2]. | Inductive | good_mem | examples.ifc-basic | examples/ifc-basic/DerivedGen.v | [
"QuickChick",
"ZArith",
"List",
"ListNotations",
"QuickChick.ifcbasic",
"Machine",
"Printing",
"Generation"
] | [
"Mem",
"good_atom"
] | Definition gen_memory := vectorOf 2 gen_atom. | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 |
is_atom_low (a : Atom) | :=
match a with
| _ @ L => true
| _ => false
end. | Definition | is_atom_low | examples.ifc-basic | examples/ifc-basic/DerivedGen.v | [
"QuickChick",
"ZArith",
"List",
"ListNotations",
"QuickChick.ifcbasic",
"Machine",
"Printing",
"Generation"
] | [
"Atom"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 | |
good_stack : nat -> Stack -> Prop | :=
| GoodStackMty : good_stack 0 Mty
| GoodStackCons : forall n a s , good_atom a -> good_stack n s -> good_stack (S n) (a :: s)
| GoodStackRet : forall n pc s, good_atom pc -> good_stack n s -> good_stack (S n) (RetCons pc s). | Inductive | good_stack | examples.ifc-basic | examples/ifc-basic/DerivedGen.v | [
"QuickChick",
"ZArith",
"List",
"ListNotations",
"QuickChick.ifcbasic",
"Machine",
"Printing",
"Generation"
] | [
"Stack",
"good_atom",
"nat"
] | I could write this without the nat to exploit the default size! | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 |
contains_ret : Stack -> Prop | :=
| RetHere : forall pc s, contains_ret (RetCons pc s)
| RetLater : forall a s, contains_ret s -> contains_ret (a :: s). | Inductive | contains_ret | examples.ifc-basic | examples/ifc-basic/DerivedGen.v | [
"QuickChick",
"ZArith",
"List",
"ListNotations",
"QuickChick.ifcbasic",
"Machine",
"Printing",
"Generation"
] | [
"Stack"
] | Definition ainstr (st : State) : G Instruction :=
let '(St im m stk pc ) := st in
let fix stack_length s :=
match s with
| _ :: s' => 1 + stack_length s'
| _ => 0
end in
let sl := stack_length stk in
let fix containsRet s :=
match s with
| _ ::: _ => true
| _ ::... | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 |
dec_contains_ret (s : Stack) : Dec (contains_ret s). | Proof.
dec_eq.
induction s.
- right => H; inversion H.
- destruct IHs.
+ left; constructor; auto.
+ right => H; inversion H; eauto.
- left; constructor; auto.
Defined. | Instance | dec_contains_ret | examples.ifc-basic | examples/ifc-basic/DerivedGen.v | [
"QuickChick",
"ZArith",
"List",
"ListNotations",
"QuickChick.ifcbasic",
"Machine",
"Printing",
"Generation"
] | [
"Dec",
"Stack",
"contains_ret",
"dec_eq"
] | https://github.com/QuickChick/QuickChick | 5a6c291b11e9affe059c0e1812612bc474d0a129 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.