fact stringlengths 5 23.4k | type stringclasses 2 values | library stringclasses 36 values | imports listlengths 0 55 | filename stringlengths 14 86 | symbolic_name stringlengths 1 68 | docstring stringclasses 1 value |
|---|---|---|---|---|---|---|
powx : x:int -> n:nat -> Tot int | val | ulib | [
"FStar.Mul"
] | ulib/FStar.Math.Lib.fst | powx | |
abs : x:int -> Tot (y:int{ (x >= 0 ==> y = x) /\ (x < 0 ==> y = -x) }) | val | ulib | [
"FStar.Mul"
] | ulib/FStar.Math.Lib.fst | abs | |
max : x:int -> y:int -> Tot (z:int{ (x >= y ==> z = x) /\ (x < y ==> z = y) }) | val | ulib | [
"FStar.Mul"
] | ulib/FStar.Math.Lib.fst | max | |
min : x:int -> y:int -> Tot (z:int{ (x >= y ==> z = y) /\ (x < y ==> z = x) }) | val | ulib | [
"FStar.Mul"
] | ulib/FStar.Math.Lib.fst | min | |
div : a:int -> b:pos -> Tot (c:int{(a < 0 ==> c < 0) /\ (a >= 0 ==> c >= 0)}) | val | ulib | [
"FStar.Mul"
] | ulib/FStar.Math.Lib.fst | div | |
div_non_eucl : a:int -> b:pos -> Tot (q:int{ ( a >= 0 ==> q = a / b ) /\ ( a < 0 ==> q = -((-a)/b) ) }) | val | ulib | [
"FStar.Mul"
] | ulib/FStar.Math.Lib.fst | div_non_eucl | |
shift_left : v:int -> i:nat -> Tot (res:int{res = v * (pow2 i)}) | val | ulib | [
"FStar.Mul"
] | ulib/FStar.Math.Lib.fst | shift_left | |
arithmetic_shift_right : v:int -> i:nat -> Tot (res:int{ res = div v (pow2 i) }) | val | ulib | [
"FStar.Mul"
] | ulib/FStar.Math.Lib.fst | arithmetic_shift_right | |
signed_modulo : v:int -> p:pos -> Tot (res:int{ res = v - ((div_non_eucl v p) * p) }) | val | ulib | [
"FStar.Mul"
] | ulib/FStar.Math.Lib.fst | signed_modulo | |
op_Plus_Percent : a:int -> p:pos -> Tot (res:int{ (a >= 0 ==> res = a % p) /\ (a < 0 ==> res = -((-a) % p)) }) | val | ulib | [
"FStar.Mul"
] | ulib/FStar.Math.Lib.fst | op_Plus_Percent | |
powx_lemma1 : a:int -> Lemma (powx a 1 = a) | val | ulib | [
"FStar.Mul"
] | ulib/FStar.Math.Lib.fst | powx_lemma1 | |
powx_lemma2 : x:int -> n:nat -> m:nat -> Lemma (powx x n * powx x m = powx x (n + m)) | val | ulib | [
"FStar.Mul"
] | ulib/FStar.Math.Lib.fst | powx_lemma2 | |
abs_mul_lemma : a:int -> b:int -> Lemma (abs (a * b) = abs a * abs b) | val | ulib | [
"FStar.Mul"
] | ulib/FStar.Math.Lib.fst | abs_mul_lemma | |
signed_modulo_property : v:int -> p:pos -> Lemma (abs (signed_modulo v p ) < p) | val | ulib | [
"FStar.Mul"
] | ulib/FStar.Math.Lib.fst | signed_modulo_property | |
div_non_eucl_decr_lemma : a:int -> b:pos -> Lemma (abs (div_non_eucl a b) <= abs a) | val | ulib | [
"FStar.Mul"
] | ulib/FStar.Math.Lib.fst | div_non_eucl_decr_lemma | |
div_non_eucl_bigger_denom_lemma : a:int -> b:pos -> Lemma (requires (b > abs a)) (ensures (div_non_eucl a b = 0)) | val | ulib | [
"FStar.Mul"
] | ulib/FStar.Math.Lib.fst | div_non_eucl_bigger_denom_lemma | |
matrix c m n = z:SB.seq c { SB.length z = m*n } | type | ulib | [
"FStar.IntegerIntervals",
"FStar.Mul",
"FStar.Seq.Equiv",
"FStar.Algebra.CommMonoid.Equiv",
"FStar.Algebra.CommMonoid.Fold",
"FStar.Seq.Permutation",
"FStar.Seq.Base",
"FStar.Seq.Properties"
] | ulib/FStar.Matrix.fst | matrix | |
loc_aux : Type = | LocBuffer: | type | ulib | [
"FStar.HyperStack",
"FStar.Buffer",
"FStar.ModifiesGen"
] | ulib/FStar.Modifies.fst | loc_aux | |
aloc (#al: aloc_t) (c: cls al) = | ALoc: | type | ulib | [
"FStar.Stubs.Tactics.V2.Builtins",
"FStar.Tactics.SMT",
"FStar.Stubs.Tactics.V2.Builtins",
"FStar.Stubs.Tactics.V2.Builtins",
"FStar.Tactics.SMT",
"FStar.Stubs.Tactics.V2.Builtins",
"FStar.Tactics.SMT",
"FStar.Stubs.Tactics.V2.Builtins",
"FStar.Tactics.SMT",
"FStar.HyperStack",
"FStar.Functional... | ulib/FStar.ModifiesGen.fst | aloc | |
loc' (#al: aloc_t u#x) (c: cls al) : Type u#x = | Loc: | type | ulib | [
"FStar.Stubs.Tactics.V2.Builtins",
"FStar.Tactics.SMT",
"FStar.Stubs.Tactics.V2.Builtins",
"FStar.Stubs.Tactics.V2.Builtins",
"FStar.Tactics.SMT",
"FStar.Stubs.Tactics.V2.Builtins",
"FStar.Tactics.SMT",
"FStar.Stubs.Tactics.V2.Builtins",
"FStar.Tactics.SMT",
"FStar.HyperStack",
"FStar.Functional... | ulib/FStar.ModifiesGen.fst | loc' | |
heap_rec = { | type | ulib | [
"FStar.Preorder",
"FStar.Classical",
"FStar.FunctionalExtensionality"
] | ulib/FStar.Monotonic.Heap.fst | heap_rec | |
core_mref (a:Type0) : Type0 = { | type | ulib | [
"FStar.Preorder",
"FStar.Classical",
"FStar.FunctionalExtensionality"
] | ulib/FStar.Monotonic.Heap.fst | core_mref | |
aref' :Type0 = { | type | ulib | [
"FStar.Preorder",
"FStar.Classical",
"FStar.FunctionalExtensionality"
] | ulib/FStar.Monotonic.Heap.fst | aref' | |
lemma_extends_fresh_disjoint : i:rid -> j:rid -> ipar:rid -> jpar:rid -> (m0:mem) -> (m1:mem) -> Lemma (requires (let h0, h1 = get_hmap m0, get_hmap m1 in (map_invariant h0 /\ map_invariant h1 /\ fresh_region i m0 m1 /\ fresh_region j m0 m1 /\ h0 `Map.contains` ipar /\ h0 `Map.contains` jpar /\ extends i ipar /\ extends j jpar /\ i<>j))) (ensures (disjoint i j)) | val | ulib | [
"FStar.Preorder",
"FStar.Map"
] | ulib/FStar.Monotonic.HyperStack.fst | lemma_extends_fresh_disjoint | |
lemma_live_1 : #a:Type -> #a':Type -> #rel:preorder a -> #rel':preorder a' -> h:mem -> x:mreference a rel -> x':mreference a' rel' -> Lemma (requires (contains h x /\ x' `unused_in` h)) (ensures (frameOf x <> frameOf x' \/ ~ (as_ref x === as_ref x'))) | val | ulib | [
"FStar.Preorder",
"FStar.Map"
] | ulib/FStar.Monotonic.HyperStack.fst | lemma_live_1 | |
mem' = | HS :rid_ctr:int -> h:hmap -> tip:rid -> mem' | type | ulib | [
"FStar.Preorder",
"FStar.Map"
] | ulib/FStar.Monotonic.HyperStack.fst | mem' | |
aref = | ARef: aref_region:rid -> | type | ulib | [
"FStar.Preorder",
"FStar.Map"
] | ulib/FStar.Monotonic.HyperStack.fst | aref | |
map' (a:Type) (b:a -> Type) = (x:a -> Tot (option (b x))) | type | ulib | [
"FStar.HyperStack",
"FStar.HyperStack.ST",
"FStar.HyperStack",
"FStar.HyperStack.ST"
] | ulib/FStar.Monotonic.Map.fst | map' | |
map (a:Type) (b:a -> Type) (inv:map' a b -> Type0) = m:map' a b{inv m} | type | ulib | [
"FStar.HyperStack",
"FStar.HyperStack.ST",
"FStar.HyperStack",
"FStar.HyperStack.ST"
] | ulib/FStar.Monotonic.Map.fst | map | |
t r a b inv = m_rref r (map a b inv) grows //maybe grows can include the inv? | type | ulib | [
"FStar.HyperStack",
"FStar.HyperStack.ST",
"FStar.HyperStack",
"FStar.HyperStack.ST"
] | ulib/FStar.Monotonic.Map.fst | t | |
rid = HST.erid | type | ulib | [
"FStar.HyperStack",
"FStar.HyperStack.ST",
"FStar.HyperStack",
"FStar.HyperStack.ST"
] | ulib/FStar.Monotonic.Map.fst | rid | |
collect : ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b) (decreases (Seq.length s)) | val | ulib | [
"FStar.Seq",
"FStar.Classical",
"FStar.HyperStack",
"FStar.HyperStack.ST",
"FStar.HyperStack",
"FStar.HyperStack.ST",
"FStar.Seq"
] | ulib/FStar.Monotonic.Seq.fst | collect | |
collect_snoc : f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma (collect f (Seq.snoc s a) == Seq.append (collect f s) (f a)) | val | ulib | [
"FStar.Seq",
"FStar.Classical",
"FStar.HyperStack",
"FStar.HyperStack.ST",
"FStar.HyperStack",
"FStar.HyperStack.ST",
"FStar.Seq"
] | ulib/FStar.Monotonic.Seq.fst | collect_snoc | |
rid = HST.erid | type | ulib | [
"FStar.Seq",
"FStar.Classical",
"FStar.HyperStack",
"FStar.HyperStack.ST",
"FStar.HyperStack",
"FStar.HyperStack.ST",
"FStar.Seq"
] | ulib/FStar.Monotonic.Seq.fst | rid | |
log_t (i:rid) (a:Type) = m_rref i (seq a) grows | type | ulib | [
"FStar.Seq",
"FStar.Classical",
"FStar.HyperStack",
"FStar.HyperStack.ST",
"FStar.HyperStack",
"FStar.HyperStack.ST",
"FStar.Seq"
] | ulib/FStar.Monotonic.Seq.fst | log_t | |
seqn_val (#l:rid) (#a:Type) (i:rid) (log:log_t l a) (max:nat) = (x:nat{x <= max /\ witnessed (at_most_log_len x log)}) //never more than the length of the log | type | ulib | [
"FStar.Seq",
"FStar.Classical",
"FStar.HyperStack",
"FStar.HyperStack.ST",
"FStar.HyperStack",
"FStar.HyperStack.ST",
"FStar.Seq"
] | ulib/FStar.Monotonic.Seq.fst | seqn_val | |
seqn (#l:rid) (#a:Type) (i:rid) (log:log_t l a) (max:nat) = m_rref i //counter in region i | type | ulib | [
"FStar.Seq",
"FStar.Classical",
"FStar.HyperStack",
"FStar.HyperStack.ST",
"FStar.HyperStack",
"FStar.HyperStack.ST",
"FStar.Seq"
] | ulib/FStar.Monotonic.Seq.fst | seqn | |
get_weakening : #world:Type -> p:(world -> Type0) -> q:(world -> Type0) -> Lemma (requires (forall w. p w ==> q w)) (ensures (get p ==> get q)) [SMTPat (get p); SMTPat (get q)] (* Interaction axioms between the get and set operators *) | val | ulib | [
"FStar.Preorder"
] | ulib/FStar.Monotonic.Witnessed.fst | get_weakening | |
get_set_axiom : #world:Type -> p:Type0 -> Lemma (get (set #world p) <==> p) [SMTPat (get (set #world p))] assume val set_get_axiom :#world:Type -> w:world -> p:(world -> Type0) -> Lemma (set (get p) w <==> set (p w) w) [SMTPat (set (get p) w)] assume val set_set_axiom :#world:Type -> w:world -> w':world -> p:Type0 -> Lemma (set (set p w') w <==> set p w') [SMTPat (set (set p w') w)] (* Useful derivable get lemma *) private val get_constant_lemma :world:Type -> p:Type0 -> Lemma (get #world (fun _ -> p) <==> p) | val | ulib | [
"FStar.Preorder"
] | ulib/FStar.Monotonic.Witnessed.fst | get_set_axiom | |
get_true : world:Type -> Lemma (get #world (fun _ -> True)) | val | ulib | [
"FStar.Preorder"
] | ulib/FStar.Monotonic.Witnessed.fst | get_true | |
set_true : #world:Type -> w:world -> Lemma (set True w) private val get_false :world:Type -> Lemma (requires (get #world (fun _ -> False))) (ensures (False)) | val | ulib | [
"FStar.Preorder"
] | ulib/FStar.Monotonic.Witnessed.fst | set_true | |
set_false : #world:Type -> w:world -> Lemma (requires (set False w)) (ensures (False)) private val get_and_1 :#world:Type -> p:(world -> Type0) -> q:(world -> Type0) -> Lemma (requires (get (fun w -> p w /\ q w))) (ensures (get p /\ get q)) | val | ulib | [
"FStar.Preorder"
] | ulib/FStar.Monotonic.Witnessed.fst | set_false | |
set_and_1 : #world:Type -> w:world -> p:Type0 -> q:Type0 -> Lemma (requires (set (p /\ q) w)) (ensures (set p w /\ set q w)) assume private val get_and_2 :#world:Type -> p:(world -> Type0) -> q:(world -> Type0) -> Lemma (requires (get p /\ get q)) (ensures (get (fun w -> p w /\ q w))) assume private val set_and_2 :#world:Type -> w:world -> p:Type0 -> q:Type0 -> Lemma (requires (set p w /\ set q w)) (ensures (set (p /\ q) w)) private val get_or_1 :#world:Type -> p:(world -> Type0) -> q:(world -> Type0) -> Lemma (requires (get p \/ get q)) (ensures (get (fun w -> p w \/ q w))) | val | ulib | [
"FStar.Preorder"
] | ulib/FStar.Monotonic.Witnessed.fst | set_and_1 | |
set_or_1 : #world:Type -> w:world -> p:Type0 -> q:Type0 -> Lemma (requires (set p w \/ set q w)) (ensures (set (p \/ q) w)) assume private val get_or_2 :#world:Type -> p:(world -> Type0) -> q:(world -> Type0) -> Lemma (requires (get (fun w -> p w \/ q w))) (ensures (get p \/ get q)) assume private val set_or_2 :#world:Type -> w:world -> p:Type0 -> q:Type0 -> Lemma (requires (set (p \/ q) w)) (ensures (set p w \/ set q w)) private val get_impl_1 :#world:Type -> p:(world -> Type0) -> q:(world -> Type0) -> Lemma (requires (get (fun w -> p w ==> q w) /\ get p)) (ensures (get q)) | val | ulib | [
"FStar.Preorder"
] | ulib/FStar.Monotonic.Witnessed.fst | set_or_1 | |
set_impl_1 : #world:Type -> w:world -> p:Type0 -> q:Type0 -> Lemma (requires (set (p ==> q) w /\ set p w)) (ensures (set q w)) assume private val get_impl_2 :#world:Type -> p:(world -> Type0) -> q:(world -> Type0) -> Lemma (requires (get p ==> get q)) (ensures (get (fun w -> p w ==> q w))) assume private val set_impl_2 :#world:Type -> w:world -> p:Type0 -> q:Type0 -> Lemma (requires (set p w ==> set q w)) (ensures (set (p ==> q) w)) private val get_forall_1_aux :#world:Type -> #t:Type -> p:(t -> world -> Type0) -> x:t -> Lemma (requires (get (fun w -> forall x. p x w))) (ensures (get (fun w -> p x w))) | val | ulib | [
"FStar.Preorder"
] | ulib/FStar.Monotonic.Witnessed.fst | set_impl_1 | |
get_forall_1 : #world:Type -> #t:Type -> p:(t -> world -> Type0) -> Lemma (requires (get (fun w -> forall x. p x w))) (ensures (forall x. get (fun w -> p x w))) | val | ulib | [
"FStar.Preorder"
] | ulib/FStar.Monotonic.Witnessed.fst | get_forall_1 | |
set_forall_1 : #world:Type -> #t:Type -> w:world -> p:(t -> Type0) -> Lemma (requires (set (forall x. p x) w)) (ensures (forall x. set (p x) w)) assume private val get_forall_2 :#world:Type -> #t:Type -> p:(t -> world -> Type0) -> Lemma (requires (forall x. get (fun w -> p x w))) (ensures (get (fun w -> forall x. p x w))) assume private val set_forall_2 :#world:Type -> #t:Type -> w:world -> p:(t -> Type0) -> Lemma (requires (forall x. set (p x) w)) (ensures (set (forall x. p x) w)) private val get_exists_1_aux :#world:Type -> #t:Type -> p:(t -> world -> Type0) -> x:t -> Lemma (requires (get (fun w -> p x w))) (ensures (get (fun w -> exists x. p x w))) | val | ulib | [
"FStar.Preorder"
] | ulib/FStar.Monotonic.Witnessed.fst | set_forall_1 | |
get_exists_1 : #world:Type -> #t:Type -> p:(t -> world -> Type0) -> Lemma (requires (exists x. get (fun w -> p x w))) (ensures (get (fun w -> exists x. p x w))) | val | ulib | [
"FStar.Preorder"
] | ulib/FStar.Monotonic.Witnessed.fst | get_exists_1 | |
set_exists_1 : #world:Type -> #t:Type -> w:world -> p:(t -> Type0) -> Lemma (requires (exists x. set (p x) w)) (ensures (set (exists x. p x) w)) assume private val get_exists_2 :#world:Type -> #t:Type -> p:(t -> world -> Type0) -> Lemma (requires (get (fun w -> exists x. p x w))) (ensures (exists x. get (fun w -> p x w))) assume private val set_exists_2 :#world:Type -> #t:Type -> w:world -> p:(t -> Type0) -> Lemma (requires (set (exists x. p x) w)) (ensures (exists x. set (p x) w)) private val get_eq :#world:Type -> #t:Type -> v:t -> v':t -> Lemma (get #world (fun _ -> v == v') <==> v == v') | val | ulib | [
"FStar.Preorder"
] | ulib/FStar.Monotonic.Witnessed.fst | set_exists_1 | |
set_eq : #world:Type -> #t:Type -> w:world -> v:t -> v':t -> Lemma (set (v == v') w <==> v == v') (* NOT EXPOSED BY THE INTERFACE [end] *) (* EXPOSED BY THE INTERFACE [start] *) (* Witnessed modality *) let witnessed #state rel p = get (fun s -> forall s'. rel s s' ==> p s') (* Weakening for the witnessed modality *) let lemma_witnessed_weakening #state rel p q = () (* Some logical properties of the witnessed modality *) let lemma_witnessed_constant #state rel p = get_constant_lemma state p let lemma_witnessed_nested #state rel p = () let lemma_witnessed_and #state rel p q = let aux () :Lemma (requires (witnessed rel p /\ witnessed rel q)) (ensures (witnessed rel (fun s -> p s /\ q s))) = get_and_2 (fun s -> forall s'. rel s s' ==> p s') (fun s -> forall s'. rel s s' ==> q s') in FStar.Classical.move_requires aux () let lemma_witnessed_or #state rel p q = () let lemma_witnessed_impl #state rel p q = let aux () :Lemma (requires ((witnessed rel (fun s -> p s ==> q s) /\ witnessed rel p))) (ensures (witnessed rel q)) = get_and_2 (fun s -> forall s'. rel s s' ==> p s' ==> q s') (fun s -> forall s'. rel s s' ==> p s') in FStar.Classical.move_requires aux () let lemma_witnessed_forall #state #t rel p = let aux () :Lemma (requires (forall x. witnessed rel (fun s -> p x s))) (ensures (witnessed rel (fun s -> forall x. p x s))) = get_forall_2 #state #t (fun x s -> forall s'. rel s s' ==> p x s') in FStar.Classical.move_requires aux () let lemma_witnessed_exists #state #t rel p = () (* EXPOSED BY THE INTERFACE [end] *) (* NOT EXPOSED BY THE INTERFACE [start] *) (* An equivalent past-view of the witnessed modality *) let witnessed_past (#state:Type) (rel:preorder state) (p:(state -> Type0)) = get (fun s -> exists s'. rel s' s /\ (forall s''. rel s' s'' ==> p s'')) val witnessed_defs_equiv_1 :#state:Type -> rel:preorder state -> p:(state -> Type0) -> Lemma (requires (witnessed #state rel p)) (ensures (witnessed #state rel p)) | val | ulib | [
"FStar.Preorder"
] | ulib/FStar.Monotonic.Witnessed.fst | set_eq | |
witnessed_defs_equiv_2 : #state:Type -> rel:preorder state -> p:(state -> Type0) -> Lemma (requires (witnessed #state rel p)) (ensures (witnessed #state rel p)) | val | ulib | [
"FStar.Preorder"
] | ulib/FStar.Monotonic.Witnessed.fst | witnessed_defs_equiv_2 | |
norm_step = | Simpl // Logical simplification, e.g., [P /\ True ~> P] | type | ulib | [
"Prims"
] | ulib/FStar.NormSteps.fst | norm_step | |
isNone : option 'a -> Tot bool | val | ulib | [
"FStar.All"
] | ulib/FStar.Option.fst | isNone | |
isSome : option 'a -> Tot bool | val | ulib | [
"FStar.All"
] | ulib/FStar.Option.fst | isSome | |
map : ('a -> ML 'b) -> option 'a -> ML (option 'b) | val | ulib | [
"FStar.All"
] | ulib/FStar.Option.fst | map | |
mapTot : ('a -> Tot 'b) -> option 'a -> Tot (option 'b) | val | ulib | [
"FStar.All"
] | ulib/FStar.Option.fst | mapTot | |
get : option 'a -> ML 'a | val | ulib | [
"FStar.All"
] | ulib/FStar.Option.fst | get | |
ge : order -> bool | val | ulib | [] | ulib/FStar.Order.fst | ge | |
le : order -> bool | val | ulib | [] | ulib/FStar.Order.fst | le | |
ne : order -> bool | val | ulib | [] | ulib/FStar.Order.fst | ne | |
gt : order -> bool | val | ulib | [] | ulib/FStar.Order.fst | gt | |
lt : order -> bool | val | ulib | [] | ulib/FStar.Order.fst | lt | |
eq : order -> bool | val | ulib | [] | ulib/FStar.Order.fst | eq | |
lex : order -> (unit -> order) -> order | val | ulib | [] | ulib/FStar.Order.fst | lex | |
order_from_int : int -> order | val | ulib | [] | ulib/FStar.Order.fst | order_from_int | |
int_of_order : order -> int | val | ulib | [] | ulib/FStar.Order.fst | int_of_order | |
compare_int : int -> int -> order | val | ulib | [] | ulib/FStar.Order.fst | compare_int | |
compare_option : ('a -> 'a -> order) -> option 'a -> option 'a -> order | val | ulib | [] | ulib/FStar.Order.fst | compare_option | |
order = | Lt | Eq | Gt | type | ulib | [] | ulib/FStar.Order.fst | order | |
fold : #a:eqtype -> #b:Type -> #f:cmp a -> (a -> b -> Tot b) -> s:ordset a f -> b -> Tot b (decreases (size s)) | val | ulib | [
"FStar.OrdSet"
] | ulib/FStar.OrdSetProps.fst | fold | |
union' : #a:eqtype -> #f:cmp a -> ordset a f -> ordset a f -> Tot (ordset a f) | val | ulib | [
"FStar.OrdSet"
] | ulib/FStar.OrdSetProps.fst | union' | |
union_lemma : #a:eqtype -> #f:cmp a -> s1:ordset a f -> s2:ordset a f -> Lemma (requires (True)) (ensures (forall x. mem x (union s1 s2) = mem x (union' s1 s2))) (decreases (size s1)) | val | ulib | [
"FStar.OrdSet"
] | ulib/FStar.OrdSetProps.fst | union_lemma | |
union_lemma' : #a:eqtype -> #f:cmp a -> s1:ordset a f -> s2:ordset a f -> Lemma (requires (True)) (ensures (union s1 s2 = union' s1 s2)) | val | ulib | [
"FStar.OrdSet"
] | ulib/FStar.OrdSetProps.fst | union_lemma' | |
bool_of_string : string -> Tot (option bool) (** A primitive parser for [int] *) | val | ulib | [] | ulib/FStar.Parse.fst | bool_of_string | |
int_of_string : string -> Tot (option int) | val | ulib | [] | ulib/FStar.Parse.fst | int_of_string | |
t k v = k ^-> option v | type | ulib | [
"FStar.FunctionalExtensionality"
] | ulib/FStar.PartialMap.fst | t | |
frame_preserving_upd (#a:Type u#a) (p:pcm a) (x y:a) = v:a{ | type | ulib | [] | ulib/FStar.PCM.fst | frame_preserving_upd | |
option (a: Type) = | None : option a | type | ulib | [
"Prims"
] | ulib/FStar.Pervasives.Native.fst | option | |
tuple2 'a 'b = | Mktuple2 : _1: 'a -> _2: 'b -> tuple2 'a 'b | type | ulib | [
"Prims"
] | ulib/FStar.Pervasives.Native.fst | tuple2 | |
tuple3 'a 'b 'c = | Mktuple3 : _1: 'a -> _2: 'b -> _3: 'c -> tuple3 'a 'b 'c | type | ulib | [
"Prims"
] | ulib/FStar.Pervasives.Native.fst | tuple3 | |
tuple4 'a 'b 'c 'd = | Mktuple4 : _1: 'a -> _2: 'b -> _3: 'c -> _4: 'd -> tuple4 'a 'b 'c 'd | type | ulib | [
"Prims"
] | ulib/FStar.Pervasives.Native.fst | tuple4 | |
tuple5 'a 'b 'c 'd 'e = | Mktuple5 : _1: 'a -> _2: 'b -> _3: 'c -> _4: 'd -> _5: 'e -> tuple5 'a 'b 'c 'd 'e | type | ulib | [
"Prims"
] | ulib/FStar.Pervasives.Native.fst | tuple5 | |
tuple6 'a 'b 'c 'd 'e 'f = | Mktuple6 : _1: 'a -> _2: 'b -> _3: 'c -> _4: 'd -> _5: 'e -> _6: 'f -> tuple6 'a 'b 'c 'd 'e 'f | type | ulib | [
"Prims"
] | ulib/FStar.Pervasives.Native.fst | tuple6 | |
tuple7 'a 'b 'c 'd 'e 'f 'g = | Mktuple7 : _1: 'a -> _2: 'b -> _3: 'c -> _4: 'd -> _5: 'e -> _6: 'f -> _7: 'g | type | ulib | [
"Prims"
] | ulib/FStar.Pervasives.Native.fst | tuple7 | |
tuple8 'a 'b 'c 'd 'e 'f 'g 'h = | Mktuple8 : _1: 'a -> _2: 'b -> _3: 'c -> _4: 'd -> _5: 'e -> _6: 'f -> _7: 'g -> _8: 'h | type | ulib | [
"Prims"
] | ulib/FStar.Pervasives.Native.fst | tuple8 | |
tuple9 'a 'b 'c 'd 'e 'f 'g 'h 'i = | Mktuple9 : | type | ulib | [
"Prims"
] | ulib/FStar.Pervasives.Native.fst | tuple9 | |
tuple10 'a 'b 'c 'd 'e 'f 'g 'h 'i 'j = | Mktuple10 : | type | ulib | [
"Prims"
] | ulib/FStar.Pervasives.Native.fst | tuple10 | |
tuple11 'a 'b 'c 'd 'e 'f 'g 'h 'i 'j 'k = | Mktuple11 : | type | ulib | [
"Prims"
] | ulib/FStar.Pervasives.Native.fst | tuple11 | |
tuple12 'a 'b 'c 'd 'e 'f 'g 'h 'i 'j 'k 'l = | Mktuple12 : | type | ulib | [
"Prims"
] | ulib/FStar.Pervasives.Native.fst | tuple12 | |
tuple13 'a 'b 'c 'd 'e 'f 'g 'h 'i 'j 'k 'l 'm = | Mktuple13 : | type | ulib | [
"Prims"
] | ulib/FStar.Pervasives.Native.fst | tuple13 | |
tuple14 'a 'b 'c 'd 'e 'f 'g 'h 'i 'j 'k 'l 'm 'n = | Mktuple14 : | type | ulib | [
"Prims"
] | ulib/FStar.Pervasives.Native.fst | tuple14 | |
relation (a:Type) = a -> a -> Type0 | type | ulib | [] | ulib/FStar.Preorder.fst | relation | |
predicate (a:Type) = a -> Type0 | type | ulib | [] | ulib/FStar.Preorder.fst | predicate | |
preorder (a:Type) = rel:relation a{preorder_rel rel} | type | ulib | [] | ulib/FStar.Preorder.fst | preorder | |
extension = | MkExtension : #a:Type0 -> $f:(a -> Tot string) -> extension | type | ulib | [
"FStar.Char",
"FStar.String"
] | ulib/FStar.Printf.fst | extension | |
arg = | Bool | type | ulib | [
"FStar.Char",
"FStar.String"
] | ulib/FStar.Printf.fst | arg | |
let arg_type (a:arg) : Tot Type0 = match a with | type | ulib | [
"FStar.Char",
"FStar.String"
] | ulib/FStar.Printf.fst | let | |
dir = | Lit of char | type | ulib | [
"FStar.Char",
"FStar.String"
] | ulib/FStar.Printf.fst | dir | |
let rec dir_type (ds:list dir) : Tot Type0 = match ds with | type | ulib | [
"FStar.Char",
"FStar.String"
] | ulib/FStar.Printf.fst | let | |
ds
= match ds with | type | ulib | [
"FStar.Char",
"FStar.String"
] | ulib/FStar.Printf.fst | ds |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.