file_name stringlengths 5 52 | name stringlengths 4 95 | original_source_type stringlengths 0 23k | source_type stringlengths 9 23k | source_definition stringlengths 9 57.9k | source dict | source_range dict | file_context stringlengths 0 721k | dependencies dict | opens_and_abbrevs listlengths 2 94 | vconfig dict | interleaved bool 1
class | verbose_type stringlengths 1 7.42k | effect stringclasses 118
values | effect_flags listlengths 0 2 | mutual_with listlengths 0 11 | ideal_premises listlengths 0 236 | proof_features listlengths 0 1 | is_simple_lemma bool 2
classes | is_div bool 2
classes | is_proof bool 2
classes | is_simply_typed bool 2
classes | is_type bool 2
classes | partial_definition stringlengths 5 3.99k | completed_definiton stringlengths 1 1.63M | isa_cross_project_example bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Vale.Lib.Seqs.fst | Vale.Lib.Seqs.reveal_opaque_rec | val reveal_opaque_rec : s: Prims.string -> x: _
-> FStar.Pervasives.Lemma
(ensures FStar.Pervasives.norm [FStar.Pervasives.zeta; FStar.Pervasives.delta_only [s]] x == x) | let reveal_opaque_rec (s:string) = norm_spec [zeta; delta_only [s]] | {
"file_name": "vale/code/lib/collections/Vale.Lib.Seqs.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 67,
"end_line": 93,
"start_col": 0,
"start_line": 93
} | module Vale.Lib.Seqs
open FStar.Mul
let lemma_slice_first_exactly_in_append (#a:Type) (x y:seq a) :
Lemma (slice (append x y) 0 (length x) == x) =
let xy = append x y in
let xy_slice = slice xy 0 (length x) in
let x_slice = slice x 0 (length x) in
assert(equal xy_slice x_slice); // OBSERVE: extensionality
... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.Seqs.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s: Prims.string -> x: _
-> FStar.Pervasives.Lemma
(ensures FStar.Pervasives.norm [FStar.Pervasives.zeta; FStar.Pervasives.delta_only [s]] x == x) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.string",
"FStar.Pervasives.norm_spec",
"Prims.Cons",
"FStar.Pervasives.norm_step",
"FStar.Pervasives.zeta",
"FStar.Pervasives.delta_only",
"Prims.Nil",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Pervasives.norm",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let reveal_opaque_rec (s: string) =
| norm_spec [zeta; delta_only [s]] | false | |
Tutorial.fst | Tutorial.tau3 | val tau3: Prims.unit -> Tac unit | val tau3: Prims.unit -> Tac unit | let tau3 () : Tac unit =
Tactics.split ();
smt ();
trivial () | {
"file_name": "examples/tactics/Tutorial.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 12,
"end_line": 112,
"start_col": 0,
"start_line": 109
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.fst.checked"
],
"interface_file": false,
"source_file": "Tutorial.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.List",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | _: Prims.unit -> FStar.Tactics.Effect.Tac Prims.unit | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.unit",
"FStar.Tactics.V2.Derived.trivial",
"FStar.Tactics.V2.Derived.smt",
"FStar.Tactics.V1.Logic.split"
] | [] | false | true | false | false | false | let tau3 () : Tac unit =
| Tactics.split ();
smt ();
trivial () | false |
FStar.ImmutableArray.fsti | FStar.ImmutableArray.elem_precedes | val elem_precedes (#a: Type u#a) (s: t a) (i: nat{i < length s}) : Lemma (index s i << s) | val elem_precedes (#a: Type u#a) (s: t a) (i: nat{i < length s}) : Lemma (index s i << s) | let elem_precedes (#a:Type u#a) (s:t a) (i : nat{i < length s})
: Lemma (index s i << s)
= FStar.List.Tot.(
to_list_precedes s;
let l = to_list s in
assert (memP (index l i) l);
memP_precedes (index l i) l
) | {
"file_name": "ulib/FStar.ImmutableArray.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 81,
"start_col": 0,
"start_line": 74
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.ImmutableArray.Base.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.ImmutableArray.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.ImmutableArray.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FSta... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s: FStar.ImmutableArray.Base.t a -> i: Prims.nat{i < FStar.ImmutableArray.Base.length s}
-> FStar.Pervasives.Lemma (ensures FStar.ImmutableArray.Base.index s i << s) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ImmutableArray.Base.t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.ImmutableArray.Base.length",
"FStar.List.Tot.Properties.memP_precedes",
"FStar.List.Tot.Base.index",
"Prims.unit",
"Prims._assert",
"FStar.List.Tot.Base.memP",
"Prims.list",
"FStar.ImmutableArray.to_list",
"... | [] | true | false | true | false | false | let elem_precedes (#a: Type u#a) (s: t a) (i: nat{i < length s}) : Lemma (index s i << s) =
| let open FStar.List.Tot in
to_list_precedes s;
let l = to_list s in
assert (memP (index l i) l);
memP_precedes (index l i) l | false |
Tutorial.fst | Tutorial.is_conj | val is_conj: Prims.unit -> Tac bool | val is_conj: Prims.unit -> Tac bool | let is_conj () : Tac bool =
let g = cur_goal () in
match term_as_formula g with
| And _ _ -> true
| _ -> false | {
"file_name": "examples/tactics/Tutorial.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 20,
"end_line": 168,
"start_col": 0,
"start_line": 164
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.fst.checked"
],
"interface_file": false,
"source_file": "Tutorial.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.List",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | _: Prims.unit -> FStar.Tactics.Effect.Tac Prims.bool | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.unit",
"FStar.Tactics.NamedView.term",
"FStar.Reflection.V2.Formula.formula",
"Prims.bool",
"FStar.Reflection.V2.Formula.term_as_formula",
"FStar.Stubs.Reflection.Types.typ",
"FStar.Tactics.V2.Derived.cur_goal"
] | [] | false | true | false | false | false | let is_conj () : Tac bool =
| let g = cur_goal () in
match term_as_formula g with
| And _ _ -> true
| _ -> false | false |
Vale.Lib.Seqs.fst | Vale.Lib.Seqs.reverse_seq_append | val reverse_seq_append (#a:eqtype) (s:seq a) (t:seq a) :
Lemma(ensures reverse_seq (append s t) == append (reverse_seq t) (reverse_seq s)) | val reverse_seq_append (#a:eqtype) (s:seq a) (t:seq a) :
Lemma(ensures reverse_seq (append s t) == append (reverse_seq t) (reverse_seq s)) | let reverse_seq_append (#a:eqtype) (s:seq a) (t:seq a) :
Lemma(ensures reverse_seq (append s t) == append (reverse_seq t) (reverse_seq s))
=
assert (equal (reverse_seq (append s t)) (append (reverse_seq t) (reverse_seq s))) | {
"file_name": "vale/code/lib/collections/Vale.Lib.Seqs.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 84,
"end_line": 21,
"start_col": 0,
"start_line": 18
} | module Vale.Lib.Seqs
open FStar.Mul
let lemma_slice_first_exactly_in_append (#a:Type) (x y:seq a) :
Lemma (slice (append x y) 0 (length x) == x) =
let xy = append x y in
let xy_slice = slice xy 0 (length x) in
let x_slice = slice x 0 (length x) in
assert(equal xy_slice x_slice); // OBSERVE: extensionality
... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.Seqs.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s: FStar.Seq.Base.seq a -> t: FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma
(ensures
Vale.Lib.Seqs_s.reverse_seq (FStar.Seq.Base.append s t) ==
FStar.Seq.Base.append (Vale.Lib.Seqs_s.reverse_seq t) (Vale.Lib.Seqs_s.reverse_seq s)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.eqtype",
"FStar.Seq.Base.seq",
"Prims._assert",
"FStar.Seq.Base.equal",
"Vale.Lib.Seqs_s.reverse_seq",
"FStar.Seq.Base.append",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let reverse_seq_append (#a: eqtype) (s t: seq a)
: Lemma (ensures reverse_seq (append s t) == append (reverse_seq t) (reverse_seq s)) =
| assert (equal (reverse_seq (append s t)) (append (reverse_seq t) (reverse_seq s))) | false |
Vale.PPC64LE.InsBasic.fst | Vale.PPC64LE.InsBasic.va_wpProof_Sl64 | val va_wpProof_Sl64 : dst:va_operand_reg_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Sl64 dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (... | val va_wpProof_Sl64 : dst:va_operand_reg_opr -> src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Sl64 dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (... | let va_wpProof_Sl64 dst src1 src2 va_s0 va_k =
let (va_sM, va_f0) = va_lemma_Sl64 (va_code_Sl64 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_reg_opr dst]) va_sM va_s0;
l... | {
"file_name": "obj/Vale.PPC64LE.InsBasic.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 708,
"start_col": 0,
"start_line": 702
} | module Vale.PPC64LE.InsBasic
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.Memory
open Vale.PPC64LE.Stack_i
friend Vale.PPC64LE.Decls
module S = Vale.PPC64LE.Semantics_s
//-- Move
[@ "opaque_to_smt"]
let va_code_Move dst src =
(Ins (S.Move dst src))
[@ "opaque_to_smt"... | {
"checked_file": "/",
"dependencies": [
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.Stack_i.fsti.checked",
"Vale.PPC64LE.Semantics_s.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.Decls.fst.checked",
"Vale.PPC64LE.Decls.fst.che... | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
dst: Vale.PPC64LE.Decls.va_operand_reg_opr ->
src1: Vale.PPC64LE.Decls.va_operand_reg_opr ->
src2: Vale.PPC64LE.Decls.va_operand_reg_opr ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Prims.Ghost ((Vale.PPC64LE.Decls.va_state * Vale.PP... | Prims.Ghost | [] | [] | [
"Vale.PPC64LE.Decls.va_operand_reg_opr",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Vale.PPC64LE.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple3",
"Vale.PPC64LE.QuickCode.va_lemma_norm_mods",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_mod_reg_opr",
"Prims.Nil",
... | [] | false | false | false | false | false | let va_wpProof_Sl64 dst src1 src2 va_s0 va_k =
| let va_sM, va_f0 = va_lemma_Sl64 (va_code_Sl64 dst src1 src2) va_s0 dst src1 src2 in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_reg_opr dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_reg_opr dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | false |
Vale.Lib.Seqs.fst | Vale.Lib.Seqs.lemma_slice_first_exactly_in_append | val lemma_slice_first_exactly_in_append (#a:Type) (x y:seq a) :
Lemma (slice (append x y) 0 (length x) == x) | val lemma_slice_first_exactly_in_append (#a:Type) (x y:seq a) :
Lemma (slice (append x y) 0 (length x) == x) | let lemma_slice_first_exactly_in_append (#a:Type) (x y:seq a) :
Lemma (slice (append x y) 0 (length x) == x) =
let xy = append x y in
let xy_slice = slice xy 0 (length x) in
let x_slice = slice x 0 (length x) in
assert(equal xy_slice x_slice); // OBSERVE: extensionality
() | {
"file_name": "vale/code/lib/collections/Vale.Lib.Seqs.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 10,
"start_col": 0,
"start_line": 4
} | module Vale.Lib.Seqs
open FStar.Mul | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.Seqs.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: FStar.Seq.Base.seq a -> y: FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma
(ensures FStar.Seq.Base.slice (FStar.Seq.Base.append x y) 0 (FStar.Seq.Base.length x) == x) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.length",
"FStar.Seq.Base.append",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let lemma_slice_first_exactly_in_append (#a: Type) (x y: seq a)
: Lemma (slice (append x y) 0 (length x) == x) =
| let xy = append x y in
let xy_slice = slice xy 0 (length x) in
let x_slice = slice x 0 (length x) in
assert (equal xy_slice x_slice);
() | false |
Tutorial.fst | Tutorial.ex1 | val ex1 : unit -> Lemma True | val ex1 : unit -> Lemma True | let ex1 () =
assert_by_tactic True idtac | {
"file_name": "examples/tactics/Tutorial.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 31,
"end_line": 63,
"start_col": 0,
"start_line": 62
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.fst.checked"
],
"interface_file": false,
"source_file": "Tutorial.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.List",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | _: Prims.unit -> FStar.Pervasives.Lemma (ensures Prims.l_True) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.l_True",
"FStar.Tactics.V2.Derived.idtac"
] | [] | true | false | true | false | false | let ex1 () =
| assert_by_tactic True idtac | false |
Tutorial.fst | Tutorial.ex2 | val ex2 : unit -> Lemma True | val ex2 : unit -> Lemma True | let ex2 () =
assert_by_tactic True (fun () -> dump "Example 2") | {
"file_name": "examples/tactics/Tutorial.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 54,
"end_line": 74,
"start_col": 0,
"start_line": 73
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.fst.checked"
],
"interface_file": false,
"source_file": "Tutorial.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.List",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | _: Prims.unit -> FStar.Pervasives.Lemma (ensures Prims.l_True) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.l_True",
"FStar.Stubs.Tactics.V2.Builtins.dump"
] | [] | false | false | true | false | false | let ex2 () =
| assert_by_tactic True (fun () -> dump "Example 2") | false |
Simple.fst | Simple.mk_n_list | val mk_n_list (#a: Type) (n: nat) (x: a) : list a | val mk_n_list (#a: Type) (n: nat) (x: a) : list a | let mk_n_list (#a:Type) (n:nat) (x:a) : list a =
let rec aux (n:nat) out =
if n = 0 then out
else aux (n - 1) (x :: out)
in
aux n [] | {
"file_name": "examples/native_tactics/Simple.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 10,
"end_line": 39,
"start_col": 0,
"start_line": 34
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Simple.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | n: Prims.nat -> x: a -> Prims.list a | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Prims.Nil",
"Prims.list",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"Prims.op_Subtraction",
"Prims.Cons"
] | [] | false | false | false | true | false | let mk_n_list (#a: Type) (n: nat) (x: a) : list a =
| let rec aux (n: nat) out = if n = 0 then out else aux (n - 1) (x :: out) in
aux n [] | false |
Vale.Lib.Seqs.fst | Vale.Lib.Seqs.lemma_all_but_last_append | val lemma_all_but_last_append (#t:Type) (a:seq t) (b:seq t{length b > 0}) :
Lemma (all_but_last (append a b) == append a (all_but_last b)) | val lemma_all_but_last_append (#t:Type) (a:seq t) (b:seq t{length b > 0}) :
Lemma (all_but_last (append a b) == append a (all_but_last b)) | let lemma_all_but_last_append (#t:Type) (a:seq t) (b:seq t{length b > 0}) :
Lemma (all_but_last (append a b) == append a (all_but_last b)) =
let ab = all_but_last (append a b) in
let app_a_b = append a (all_but_last b) in
assert (equal ab app_a_b) | {
"file_name": "vale/code/lib/collections/Vale.Lib.Seqs.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 27,
"end_line": 16,
"start_col": 0,
"start_line": 12
} | module Vale.Lib.Seqs
open FStar.Mul
let lemma_slice_first_exactly_in_append (#a:Type) (x y:seq a) :
Lemma (slice (append x y) 0 (length x) == x) =
let xy = append x y in
let xy_slice = slice xy 0 (length x) in
let x_slice = slice x 0 (length x) in
assert(equal xy_slice x_slice); // OBSERVE: extensionality
... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.Seqs.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: FStar.Seq.Base.seq t -> b: FStar.Seq.Base.seq t {FStar.Seq.Base.length b > 0}
-> FStar.Pervasives.Lemma
(ensures
Vale.Lib.Seqs_s.all_but_last (FStar.Seq.Base.append a b) ==
FStar.Seq.Base.append a (Vale.Lib.Seqs_s.all_but_last b)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.Seq.Base.length",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.append",
"Vale.Lib.Seqs_s.all_but_last",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let lemma_all_but_last_append (#t: Type) (a: seq t) (b: seq t {length b > 0})
: Lemma (all_but_last (append a b) == append a (all_but_last b)) =
| let ab = all_but_last (append a b) in
let app_a_b = append a (all_but_last b) in
assert (equal ab app_a_b) | false |
Simple.fst | Simple.id | val id : x: Prims.int{x >= 0} -> x: Prims.int{x >= 0} | let id (x:int{x >= 0}) =
let rec countdown (y:nat) =
if y=0 then x
else countdown (y - 1)
in
countdown x | {
"file_name": "examples/native_tactics/Simple.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 13,
"end_line": 23,
"start_col": 0,
"start_line": 18
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Simple.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.int{x >= 0} -> x: Prims.int{x >= 0} | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Prims.nat",
"Prims.op_Equality",
"Prims.bool",
"Prims.op_Subtraction"
] | [] | false | false | false | false | false | let id (x: int{x >= 0}) =
| let rec countdown (y: nat) = if y = 0 then x else countdown (y - 1) in
countdown x | false | |
Tutorial.fst | Tutorial.split_all | val split_all: Prims.unit -> Tac unit | val split_all: Prims.unit -> Tac unit | let rec split_all () : Tac unit =
if is_conj ()
then
begin
Tactics.split ();
iseq [split_all; split_all]
end
else
let _ = trytac trivial in
() | {
"file_name": "examples/tactics/Tutorial.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 6,
"end_line": 184,
"start_col": 0,
"start_line": 175
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.fst.checked"
],
"interface_file": false,
"source_file": "Tutorial.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.List",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | _: Prims.unit -> FStar.Tactics.Effect.Tac Prims.unit | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.unit",
"FStar.Tactics.V2.Derived.iseq",
"Prims.Cons",
"Tutorial.split_all",
"Prims.Nil",
"FStar.Tactics.V1.Logic.split",
"Prims.bool",
"FStar.Pervasives.Native.option",
"FStar.Tactics.V2.Derived.trytac",
"FStar.Tactics.V2.Derived.trivial",
"Tutorial.is_conj"
] | [
"recursion"
] | false | true | false | false | false | let rec split_all () : Tac unit =
| if is_conj ()
then
(Tactics.split ();
iseq [split_all; split_all])
else
let _ = trytac trivial in
() | false |
Vale.Lib.Seqs.fst | Vale.Lib.Seqs.seq_map_i | val seq_map_i (#a:Type) (#b:Type) (f:int->a->b) (s:seq a) :
Tot (s':seq b { length s' == length s /\
(forall j . {:pattern index s' j} 0 <= j /\ j < length s ==> index s' j == f j (index s j))
}) | val seq_map_i (#a:Type) (#b:Type) (f:int->a->b) (s:seq a) :
Tot (s':seq b { length s' == length s /\
(forall j . {:pattern index s' j} 0 <= j /\ j < length s ==> index s' j == f j (index s j))
}) | let seq_map_i (#a:Type) (#b:Type) (f:int->a->b) (s:seq a) :
Tot (s':seq b { length s' == length s /\
(forall j . {:pattern index s' j} 0 <= j /\ j < length s ==> index s' j == f j (index s j))
})
=
seq_map_i_indexed f s 0 | {
"file_name": "vale/code/lib/collections/Vale.Lib.Seqs.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 25,
"end_line": 44,
"start_col": 0,
"start_line": 39
} | module Vale.Lib.Seqs
open FStar.Mul
let lemma_slice_first_exactly_in_append (#a:Type) (x y:seq a) :
Lemma (slice (append x y) 0 (length x) == x) =
let xy = append x y in
let xy_slice = slice xy 0 (length x) in
let x_slice = slice x 0 (length x) in
assert(equal xy_slice x_slice); // OBSERVE: extensionality
... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.Seqs.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: Prims.int -> _: a -> b) -> s: FStar.Seq.Base.seq a
-> s':
FStar.Seq.Base.seq b
{ FStar.Seq.Base.length s' == FStar.Seq.Base.length s /\
(forall (j:
i:
Prims.int
{i >= 0 /\ i < FStar.Seq.Base.length s /\ (i >= 0) /\ (i < FStar.Seq.Base.length s')})
... | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"FStar.Seq.Base.seq",
"Vale.Lib.Seqs.seq_map_i_indexed",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"FStar.Seq.Base.length",
"Prims.l_Forall",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Prims.op_LessThan",
"Prims.l_imp",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.index"
] | [] | false | false | false | false | false | let seq_map_i (#a #b: Type) (f: (int -> a -> b)) (s: seq a)
: Tot
(s':
seq b
{ length s' == length s /\
(forall j. {:pattern index s' j} 0 <= j /\ j < length s ==> index s' j == f j (index s j))
}) =
| seq_map_i_indexed f s 0 | false |
Vale.PPC64LE.InsBasic.fst | Vale.PPC64LE.InsBasic.va_lemma_Sr64 | val va_lemma_Sr64 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Sr64 dst src1 src2) va_s0 /\ va_is_dst_reg_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg... | val va_lemma_Sr64 : va_b0:va_code -> va_s0:va_state -> dst:va_operand_reg_opr ->
src1:va_operand_reg_opr -> src2:va_operand_reg_opr
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Sr64 dst src1 src2) va_s0 /\ va_is_dst_reg_opr dst
va_s0 /\ va_is_src_reg_opr src1 va_s0 /\ va_is_src_reg... | let va_lemma_Sr64 va_b0 va_s0 dst src1 src2 =
va_reveal_opaque (`%va_code_Sr64) (va_code_Sr64 dst src1 src2);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (Ins (S.Sr64 dst src1 src2)) va_s0;
let (va_sM, va_fM) = va_eval_ins (Ins (S.Sr64 dst src1 src2)) va_s0 in
(va_sM, va_fM) | {
"file_name": "obj/Vale.PPC64LE.InsBasic.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 669,
"start_col": 0,
"start_line": 664
} | module Vale.PPC64LE.InsBasic
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.Memory
open Vale.PPC64LE.Stack_i
friend Vale.PPC64LE.Decls
module S = Vale.PPC64LE.Semantics_s
//-- Move
[@ "opaque_to_smt"]
let va_code_Move dst src =
(Ins (S.Move dst src))
[@ "opaque_to_smt"... | {
"checked_file": "/",
"dependencies": [
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.Stack_i.fsti.checked",
"Vale.PPC64LE.Semantics_s.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.Decls.fst.checked",
"Vale.PPC64LE.Decls.fst.che... | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
va_b0: Vale.PPC64LE.Decls.va_code ->
va_s0: Vale.PPC64LE.Decls.va_state ->
dst: Vale.PPC64LE.Decls.va_operand_reg_opr ->
src1: Vale.PPC64LE.Decls.va_operand_reg_opr ->
src2: Vale.PPC64LE.Decls.va_operand_reg_opr
-> Prims.Ghost (Vale.PPC64LE.Decls.va_state * Vale.PPC64LE.Decls.va_fuel) | Prims.Ghost | [] | [] | [
"Vale.PPC64LE.Decls.va_code",
"Vale.PPC64LE.Decls.va_state",
"Vale.PPC64LE.Decls.va_operand_reg_opr",
"Vale.PPC64LE.State.state",
"Vale.PPC64LE.Lemmas.fuel",
"FStar.Pervasives.Native.Mktuple2",
"Vale.PPC64LE.Decls.va_fuel",
"FStar.Pervasives.Native.tuple2",
"Vale.PPC64LE.Machine_s.state",
"Prims.n... | [] | false | false | false | false | false | let va_lemma_Sr64 va_b0 va_s0 dst src1 src2 =
| va_reveal_opaque (`%va_code_Sr64) (va_code_Sr64 dst src1 src2);
let va_old_s:va_state = va_s0 in
va_ins_lemma (Ins (S.Sr64 dst src1 src2)) va_s0;
let va_sM, va_fM = va_eval_ins (Ins (S.Sr64 dst src1 src2)) va_s0 in
(va_sM, va_fM) | false |
Simple.fst | Simple.poly_list_id | val poly_list_id : l: Prims.list a -> Prims.list a | let poly_list_id (#a:Type) (l:list a) =
let rec aux (l:list a) (out:list a) =
match l with
| [] -> List.Tot.rev out
| hd::tl -> aux tl (hd::out)
in
aux l [] | {
"file_name": "examples/native_tactics/Simple.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 10,
"end_line": 48,
"start_col": 0,
"start_line": 42
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Simple.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | l: Prims.list a -> Prims.list a | Prims.Tot | [
"total"
] | [] | [
"Prims.list",
"Prims.Nil",
"FStar.List.Tot.Base.rev",
"Prims.Cons"
] | [] | false | false | false | true | false | let poly_list_id (#a: Type) (l: list a) =
| let rec aux (l out: list a) =
match l with
| [] -> List.Tot.rev out
| hd :: tl -> aux tl (hd :: out)
in
aux l [] | false | |
Vale.Lib.Seqs.fst | Vale.Lib.Seqs.seq_map_inverses | val seq_map_inverses (#a #b:Type) (f:a -> b) (g:b -> a) (s:seq a) : Lemma
(requires forall x . g (f x) == x)
(ensures seq_map g (seq_map f s) == s) | val seq_map_inverses (#a #b:Type) (f:a -> b) (g:b -> a) (s:seq a) : Lemma
(requires forall x . g (f x) == x)
(ensures seq_map g (seq_map f s) == s) | let seq_map_inverses (#a #b:Type) (f:a -> b) (g:b -> a) (s:seq a) : Lemma
(requires forall x . g (f x) == x)
(ensures seq_map g (seq_map f s) == s)
=
let mid = seq_map f s in
let final = seq_map g mid in
assert (equal s final);
() | {
"file_name": "vale/code/lib/collections/Vale.Lib.Seqs.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 64,
"start_col": 0,
"start_line": 57
} | module Vale.Lib.Seqs
open FStar.Mul
let lemma_slice_first_exactly_in_append (#a:Type) (x y:seq a) :
Lemma (slice (append x y) 0 (length x) == x) =
let xy = append x y in
let xy_slice = slice xy 0 (length x) in
let x_slice = slice x 0 (length x) in
assert(equal xy_slice x_slice); // OBSERVE: extensionality
... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.Seqs.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: a -> b) -> g: (_: b -> a) -> s: FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma (requires forall (x: a). g (f x) == x)
(ensures Vale.Lib.Seqs_s.seq_map g (Vale.Lib.Seqs_s.seq_map f s) == s) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"Vale.Lib.Seqs_s.seq_map",
"Prims.l_Forall",
"Prims.eq2",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let seq_map_inverses (#a #b: Type) (f: (a -> b)) (g: (b -> a)) (s: seq a)
: Lemma (requires forall x. g (f x) == x) (ensures seq_map g (seq_map f s) == s) =
| let mid = seq_map f s in
let final = seq_map g mid in
assert (equal s final);
() | false |
Simple.fst | Simple.poly_id | val poly_id (#a: Type) (x: int{x >= 0}) (r: a) : a | val poly_id (#a: Type) (x: int{x >= 0}) (r: a) : a | let poly_id (#a:Type) (x:int{x >= 0}) (r:a) : a =
let rec countdown (y:nat) =
if y=0 then r
else countdown (y - 1)
in
countdown x | {
"file_name": "examples/native_tactics/Simple.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 13,
"end_line": 31,
"start_col": 0,
"start_line": 26
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Simple.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.int{x >= 0} -> r: a -> a | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Prims.nat",
"Prims.op_Equality",
"Prims.bool",
"Prims.op_Subtraction"
] | [] | false | false | false | false | false | let poly_id (#a: Type) (x: int{x >= 0}) (r: a) : a =
| let rec countdown (y: nat) = if y = 0 then r else countdown (y - 1) in
countdown x | false |
Vale.Lib.Seqs.fst | Vale.Lib.Seqs.seq_map_i_indexed | val seq_map_i_indexed (#a:Type) (#b:Type) (f:int->a->b) (s:seq a) (i:int) :
Tot (s':seq b { length s' == length s /\
(forall j . {:pattern index s' j} 0 <= j /\ j < length s ==> index s' j == f (i + j) (index s j))
}) | val seq_map_i_indexed (#a:Type) (#b:Type) (f:int->a->b) (s:seq a) (i:int) :
Tot (s':seq b { length s' == length s /\
(forall j . {:pattern index s' j} 0 <= j /\ j < length s ==> index s' j == f (i + j) (index s j))
}) | let rec seq_map_i_indexed (#a:Type) (#b:Type) (f:int->a->b) (s:seq a) (i:int) :
Tot (s':seq b { length s' == length s /\
(forall j . {:pattern index s' j} 0 <= j /\ j < length s ==> index s' j == f (i + j) (index s j))
})
(decreases %[(length s)])
=
if length s = 0 then emp... | {
"file_name": "vale/code/lib/collections/Vale.Lib.Seqs.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 63,
"end_line": 37,
"start_col": 0,
"start_line": 29
} | module Vale.Lib.Seqs
open FStar.Mul
let lemma_slice_first_exactly_in_append (#a:Type) (x y:seq a) :
Lemma (slice (append x y) 0 (length x) == x) =
let xy = append x y in
let xy_slice = slice xy 0 (length x) in
let x_slice = slice x 0 (length x) in
assert(equal xy_slice x_slice); // OBSERVE: extensionality
... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.Seqs.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: Prims.int -> _: a -> b) -> s: FStar.Seq.Base.seq a -> i: Prims.int
-> Prims.Tot
(s':
FStar.Seq.Base.seq b
{ FStar.Seq.Base.length s' == FStar.Seq.Base.length s /\
(forall (j:
i:
Prims.int
{ i >= 0 /\ i < FStar.Seq.Base.length s /\
... | Prims.Tot | [
"",
"total"
] | [] | [
"Prims.int",
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"FStar.Seq.Base.length",
"FStar.Seq.Base.empty",
"Prims.bool",
"FStar.Seq.Base.cons",
"FStar.Seq.Properties.head",
"Vale.Lib.Seqs.seq_map_i_indexed",
"FStar.Seq.Properties.tail",
"Prims.op_Addition",
"Prims.l_and",
"Prims.eq2",
"Prims... | [
"recursion"
] | false | false | false | false | false | let rec seq_map_i_indexed (#a #b: Type) (f: (int -> a -> b)) (s: seq a) (i: int)
: Tot
(s':
seq b
{ length s' == length s /\
(forall j. {:pattern index s' j}
0 <= j /\ j < length s ==> index s' j == f (i + j) (index s j)) })
(decreases %[(length s)]) =
| if length s = 0 then empty else cons (f i (head s)) (seq_map_i_indexed f (tail s) (i + 1)) | false |
Vale.Lib.Seqs.fst | Vale.Lib.Seqs.reverse_reverse_seq | val reverse_reverse_seq (#a:Type) (s:seq a) :
Lemma(ensures reverse_seq (reverse_seq s) == s)
[SMTPat (reverse_seq (reverse_seq s))] | val reverse_reverse_seq (#a:Type) (s:seq a) :
Lemma(ensures reverse_seq (reverse_seq s) == s)
[SMTPat (reverse_seq (reverse_seq s))] | let reverse_reverse_seq (#a:Type) (s:seq a) :
Lemma(ensures reverse_seq (reverse_seq s) == s)
=
assert (equal (reverse_seq (reverse_seq s)) s) | {
"file_name": "vale/code/lib/collections/Vale.Lib.Seqs.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 48,
"end_line": 26,
"start_col": 0,
"start_line": 23
} | module Vale.Lib.Seqs
open FStar.Mul
let lemma_slice_first_exactly_in_append (#a:Type) (x y:seq a) :
Lemma (slice (append x y) 0 (length x) == x) =
let xy = append x y in
let xy_slice = slice xy 0 (length x) in
let x_slice = slice x 0 (length x) in
assert(equal xy_slice x_slice); // OBSERVE: extensionality
... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.Seqs.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s: FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma
(ensures Vale.Lib.Seqs_s.reverse_seq (Vale.Lib.Seqs_s.reverse_seq s) == s)
[SMTPat (Vale.Lib.Seqs_s.reverse_seq (Vale.Lib.Seqs_s.reverse_seq s))] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims._assert",
"FStar.Seq.Base.equal",
"Vale.Lib.Seqs_s.reverse_seq",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let reverse_reverse_seq (#a: Type) (s: seq a) : Lemma (ensures reverse_seq (reverse_seq s) == s) =
| assert (equal (reverse_seq (reverse_seq s)) s) | false |
Vale.Lib.Seqs.fst | Vale.Lib.Seqs.slice_append_adds | val slice_append_adds (#a:Type) (s:seq a) (i:nat) (j:nat{ i <= j /\ j <= length s }) :
Lemma (slice s 0 i @| slice s i j == slice s 0 j) | val slice_append_adds (#a:Type) (s:seq a) (i:nat) (j:nat{ i <= j /\ j <= length s }) :
Lemma (slice s 0 i @| slice s i j == slice s 0 j) | let slice_append_adds (#a:Type) (s:seq a) (i:nat) (j:nat{ i <= j /\ j <= length s }) :
Lemma (slice s 0 i @| slice s i j == slice s 0 j)
=
assert (equal (slice s 0 i @| slice s i j)
(slice s 0 j));
() | {
"file_name": "vale/code/lib/collections/Vale.Lib.Seqs.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 71,
"start_col": 0,
"start_line": 66
} | module Vale.Lib.Seqs
open FStar.Mul
let lemma_slice_first_exactly_in_append (#a:Type) (x y:seq a) :
Lemma (slice (append x y) 0 (length x) == x) =
let xy = append x y in
let xy_slice = slice xy 0 (length x) in
let x_slice = slice x 0 (length x) in
assert(equal xy_slice x_slice); // OBSERVE: extensionality
... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.Seqs.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s: FStar.Seq.Base.seq a -> i: Prims.nat -> j: Prims.nat{i <= j /\ j <= FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures FStar.Seq.Base.slice s 0 i @| FStar.Seq.Base.slice s i j == FStar.Seq.Base.slice s 0 j) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.op_At_Bar",
"FStar.Seq.Base.slice",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
"FSta... | [] | true | false | true | false | false | let slice_append_adds (#a: Type) (s: seq a) (i: nat) (j: nat{i <= j /\ j <= length s})
: Lemma (slice s 0 i @| slice s i j == slice s 0 j) =
| assert (equal (slice s 0 i @| slice s i j) (slice s 0 j));
() | false |
Vale.Lib.Seqs.fst | Vale.Lib.Seqs.list_to_seq | val list_to_seq (#a:Type) (l:list a) : Pure (seq a)
(requires True)
(ensures fun s -> Seq.length s == List.length l) | val list_to_seq (#a:Type) (l:list a) : Pure (seq a)
(requires True)
(ensures fun s -> Seq.length s == List.length l) | let list_to_seq #a l =
Seq.seq_of_list l | {
"file_name": "vale/code/lib/collections/Vale.Lib.Seqs.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 19,
"end_line": 91,
"start_col": 0,
"start_line": 90
} | module Vale.Lib.Seqs
open FStar.Mul
let lemma_slice_first_exactly_in_append (#a:Type) (x y:seq a) :
Lemma (slice (append x y) 0 (length x) == x) =
let xy = append x y in
let xy_slice = slice xy 0 (length x) in
let x_slice = slice x 0 (length x) in
assert(equal xy_slice x_slice); // OBSERVE: extensionality
... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.Seqs.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | l: Prims.list a -> Prims.Pure (FStar.Seq.Base.seq a) | Prims.Pure | [] | [] | [
"Prims.list",
"FStar.Seq.Base.seq_of_list",
"FStar.Seq.Base.seq"
] | [] | false | false | false | false | false | let list_to_seq #a l =
| Seq.seq_of_list l | false |
Simple.fst | Simple.eq_int_list | val eq_int_list (l m: list int) : Tot bool (decreases l) | val eq_int_list (l m: list int) : Tot bool (decreases l) | let rec eq_int_list (l m :list int) : Tot bool (decreases l) =
match l, m with
| [], [] -> true
| l::ls, m::ms -> l = m && eq_int_list ls ms
| _ -> false | {
"file_name": "examples/native_tactics/Simple.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 14,
"end_line": 55,
"start_col": 0,
"start_line": 51
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "Simple.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | l: Prims.list Prims.int -> m: Prims.list Prims.int -> Prims.Tot Prims.bool | Prims.Tot | [
"total",
""
] | [] | [
"Prims.list",
"Prims.int",
"FStar.Pervasives.Native.Mktuple2",
"Prims.op_AmpAmp",
"Prims.op_Equality",
"Simple.eq_int_list",
"FStar.Pervasives.Native.tuple2",
"Prims.bool"
] | [
"recursion"
] | false | false | false | true | false | let rec eq_int_list (l m: list int) : Tot bool (decreases l) =
| match l, m with
| [], [] -> true
| l :: ls, m :: ms -> l = m && eq_int_list ls ms
| _ -> false | false |
Vale.Lib.Seqs.fst | Vale.Lib.Seqs.seq_map_internal_associative | val seq_map_internal_associative (#a:Type) (#b:eqtype) (f:int->a->b) (s:seq a) (pivot:int{0 <= pivot /\ pivot < length s}) :
Lemma (let left,right = split s pivot in
seq_map_i f s == seq_map_i_indexed f left 0 @| seq_map_i_indexed f right pivot ) | val seq_map_internal_associative (#a:Type) (#b:eqtype) (f:int->a->b) (s:seq a) (pivot:int{0 <= pivot /\ pivot < length s}) :
Lemma (let left,right = split s pivot in
seq_map_i f s == seq_map_i_indexed f left 0 @| seq_map_i_indexed f right pivot ) | let seq_map_internal_associative (#a:Type) (#b:eqtype) (f:int->a->b) (s:seq a) (pivot:int{0 <= pivot /\ pivot < length s}) :
Lemma (let left,right = split s pivot in
seq_map_i f s == seq_map_i_indexed f left 0 @| seq_map_i_indexed f right pivot )
=
let left,right = split s pivot in
let full_map = seq_m... | {
"file_name": "vale/code/lib/collections/Vale.Lib.Seqs.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 55,
"start_col": 0,
"start_line": 46
} | module Vale.Lib.Seqs
open FStar.Mul
let lemma_slice_first_exactly_in_append (#a:Type) (x y:seq a) :
Lemma (slice (append x y) 0 (length x) == x) =
let xy = append x y in
let xy_slice = slice xy 0 (length x) in
let x_slice = slice x 0 (length x) in
assert(equal xy_slice x_slice); // OBSERVE: extensionality
... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.Seqs.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
f: (_: Prims.int -> _: a -> b) ->
s: FStar.Seq.Base.seq a ->
pivot: Prims.int{0 <= pivot /\ pivot < FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures
(let _ = FStar.Seq.Properties.split s pivot in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ left right = _ in
Vale.Lib... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.eqtype",
"Prims.int",
"FStar.Seq.Base.seq",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"Vale.Lib.Seqs.seq_map_i",
"FStar.Seq.Base.op_At_Bar",
"Vale.Lib.Seqs.seq_map_i_in... | [] | false | false | true | false | false | let seq_map_internal_associative
(#a: Type)
(#b: eqtype)
(f: (int -> a -> b))
(s: seq a)
(pivot: int{0 <= pivot /\ pivot < length s})
: Lemma
(let left, right = split s pivot in
seq_map_i f s == seq_map_i_indexed f left 0 @| seq_map_i_indexed f right pivot) =
| let left, right = split s pivot in
let full_map = seq_map_i f s in
let part1 = seq_map_i_indexed f left 0 in
let part2 = seq_map_i_indexed f right pivot in
assert (equal (seq_map_i f s) (seq_map_i_indexed f left 0 @| seq_map_i_indexed f right pivot));
() | false |
Vale.Lib.Seqs.fst | Vale.Lib.Seqs.slice_seq_map_commute | val slice_seq_map_commute (#a #b:Type) (f:a -> b) (s:seq a) (i:nat) (j:nat{ i <= j /\ j <= length s }) :
Lemma (slice (seq_map f s) i j == seq_map f (slice s i j)) | val slice_seq_map_commute (#a #b:Type) (f:a -> b) (s:seq a) (i:nat) (j:nat{ i <= j /\ j <= length s }) :
Lemma (slice (seq_map f s) i j == seq_map f (slice s i j)) | let slice_seq_map_commute (#a #b:Type) (f:a -> b) (s:seq a) (i:nat) (j:nat{ i <= j /\ j <= length s }) :
Lemma (slice (seq_map f s) i j == seq_map f (slice s i j))
=
assert (equal (slice (seq_map f s) i j) (seq_map f (slice s i j)));
() | {
"file_name": "vale/code/lib/collections/Vale.Lib.Seqs.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 77,
"start_col": 0,
"start_line": 73
} | module Vale.Lib.Seqs
open FStar.Mul
let lemma_slice_first_exactly_in_append (#a:Type) (x y:seq a) :
Lemma (slice (append x y) 0 (length x) == x) =
let xy = append x y in
let xy_slice = slice xy 0 (length x) in
let x_slice = slice x 0 (length x) in
assert(equal xy_slice x_slice); // OBSERVE: extensionality
... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.Seqs.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
f: (_: a -> b) ->
s: FStar.Seq.Base.seq a ->
i: Prims.nat ->
j: Prims.nat{i <= j /\ j <= FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.slice (Vale.Lib.Seqs_s.seq_map f s) i j ==
Vale.Lib.Seqs_s.seq_map f (FStar.Seq.Base.slice s i j)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.slice",
"Vale.Lib.Seqs_s.seq_map",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
"FStar... | [] | true | false | true | false | false | let slice_seq_map_commute
(#a #b: Type)
(f: (a -> b))
(s: seq a)
(i: nat)
(j: nat{i <= j /\ j <= length s})
: Lemma (slice (seq_map f s) i j == seq_map f (slice s i j)) =
| assert (equal (slice (seq_map f s) i j) (seq_map f (slice s i j)));
() | false |
Vale.Lib.Seqs.fst | Vale.Lib.Seqs.seq_map_injective | val seq_map_injective (#a #b:Type) (f:a -> b) (s s':seq a) : Lemma
(requires (forall (x x':a).{:pattern (f x); (f x')} f x == f x' ==> x == x') /\ seq_map f s == seq_map f s')
(ensures s == s') | val seq_map_injective (#a #b:Type) (f:a -> b) (s s':seq a) : Lemma
(requires (forall (x x':a).{:pattern (f x); (f x')} f x == f x' ==> x == x') /\ seq_map f s == seq_map f s')
(ensures s == s') | let seq_map_injective #a #b f s s' =
assert (forall (i:nat).{:pattern index s i} i < length s ==> index (seq_map f s) i == f (index s i));
assert (forall (i:nat).{:pattern index s i} i < length s ==> index (seq_map f s') i == f (index s' i));
assert (equal s s') | {
"file_name": "vale/code/lib/collections/Vale.Lib.Seqs.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 21,
"end_line": 88,
"start_col": 0,
"start_line": 85
} | module Vale.Lib.Seqs
open FStar.Mul
let lemma_slice_first_exactly_in_append (#a:Type) (x y:seq a) :
Lemma (slice (append x y) 0 (length x) == x) =
let xy = append x y in
let xy_slice = slice xy 0 (length x) in
let x_slice = slice x 0 (length x) in
assert(equal xy_slice x_slice); // OBSERVE: extensionality
... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.Seqs.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: a -> b) -> s: FStar.Seq.Base.seq a -> s': FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma
(requires
(forall (x: a) (x': a). {:pattern f x; f x'} f x == f x' ==> x == x') /\
Vale.Lib.Seqs_s.seq_map f s == Vale.Lib.Seqs_s.seq_map f s') (ensures s == s') | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims._assert",
"FStar.Seq.Base.equal",
"Prims.unit",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.eq2",
"FStar.Seq.Base.index",
"Vale.Lib.Seqs_s.seq_map"
] | [] | false | false | true | false | false | let seq_map_injective #a #b f s s' =
| assert (forall (i: nat). {:pattern index s i}
i < length s ==> index (seq_map f s) i == f (index s i));
assert (forall (i: nat). {:pattern index s i}
i < length s ==> index (seq_map f s') i == f (index s' i));
assert (equal s s') | false |
FStar.Reflection.V2.Arith.fst | FStar.Reflection.V2.Arith.lt | val lt : e1: FStar.Reflection.V2.Arith.expr -> e2: FStar.Reflection.V2.Arith.expr
-> FStar.Reflection.V2.Arith.prop | let lt e1 e2 = CompProp e1 C_Lt e2 | {
"file_name": "ulib/FStar.Reflection.V2.Arith.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 34,
"end_line": 65,
"start_col": 0,
"start_line": 65
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.c... | [
{
"abbrev": true,
"full_module": "FStar.Order",
"short_module": "O"
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | e1: FStar.Reflection.V2.Arith.expr -> e2: FStar.Reflection.V2.Arith.expr
-> FStar.Reflection.V2.Arith.prop | Prims.Tot | [
"total"
] | [] | [
"FStar.Reflection.V2.Arith.expr",
"FStar.Reflection.V2.Arith.CompProp",
"FStar.Reflection.V2.Arith.C_Lt",
"FStar.Reflection.V2.Arith.prop"
] | [] | false | false | false | true | false | let lt e1 e2 =
| CompProp e1 C_Lt e2 | false | |
Vale.Lib.Seqs.fst | Vale.Lib.Seqs.append_distributes_seq_map | val append_distributes_seq_map (#a #b:Type) (f:a -> b) (s1 s2:seq a) :
Lemma (seq_map f (s1 @| s2) == seq_map f s1 @| seq_map f s2) | val append_distributes_seq_map (#a #b:Type) (f:a -> b) (s1 s2:seq a) :
Lemma (seq_map f (s1 @| s2) == seq_map f s1 @| seq_map f s2) | let append_distributes_seq_map (#a #b:Type) (f:a -> b) (s1 s2:seq a) :
Lemma (seq_map f (s1 @| s2) == seq_map f s1 @| seq_map f s2)
=
assert (equal (seq_map f (s1 @| s2)) (seq_map f s1 @| seq_map f s2));
() | {
"file_name": "vale/code/lib/collections/Vale.Lib.Seqs.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 83,
"start_col": 0,
"start_line": 79
} | module Vale.Lib.Seqs
open FStar.Mul
let lemma_slice_first_exactly_in_append (#a:Type) (x y:seq a) :
Lemma (slice (append x y) 0 (length x) == x) =
let xy = append x y in
let xy_slice = slice xy 0 (length x) in
let x_slice = slice x 0 (length x) in
assert(equal xy_slice x_slice); // OBSERVE: extensionality
... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.Seqs.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: a -> b) -> s1: FStar.Seq.Base.seq a -> s2: FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma
(ensures
Vale.Lib.Seqs_s.seq_map f (s1 @| s2) ==
Vale.Lib.Seqs_s.seq_map f s1 @| Vale.Lib.Seqs_s.seq_map f s2) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"Vale.Lib.Seqs_s.seq_map",
"FStar.Seq.Base.op_At_Bar",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let append_distributes_seq_map (#a #b: Type) (f: (a -> b)) (s1 s2: seq a)
: Lemma (seq_map f (s1 @| s2) == seq_map f s1 @| seq_map f s2) =
| assert (equal (seq_map f (s1 @| s2)) (seq_map f s1 @| seq_map f s2));
() | false |
FStar.Reflection.V2.Arith.fst | FStar.Reflection.V2.Arith.eq | val eq : e1: FStar.Reflection.V2.Arith.expr -> e2: FStar.Reflection.V2.Arith.expr
-> FStar.Reflection.V2.Arith.prop | let eq e1 e2 = CompProp e1 C_Eq e2 | {
"file_name": "ulib/FStar.Reflection.V2.Arith.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 34,
"end_line": 67,
"start_col": 0,
"start_line": 67
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.c... | [
{
"abbrev": true,
"full_module": "FStar.Order",
"short_module": "O"
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | e1: FStar.Reflection.V2.Arith.expr -> e2: FStar.Reflection.V2.Arith.expr
-> FStar.Reflection.V2.Arith.prop | Prims.Tot | [
"total"
] | [] | [
"FStar.Reflection.V2.Arith.expr",
"FStar.Reflection.V2.Arith.CompProp",
"FStar.Reflection.V2.Arith.C_Eq",
"FStar.Reflection.V2.Arith.prop"
] | [] | false | false | false | true | false | let eq e1 e2 =
| CompProp e1 C_Eq e2 | false | |
FStar.Reflection.V2.Arith.fst | FStar.Reflection.V2.Arith.ne | val ne : e1: FStar.Reflection.V2.Arith.expr -> e2: FStar.Reflection.V2.Arith.expr
-> FStar.Reflection.V2.Arith.prop | let ne e1 e2 = CompProp e1 C_Ne e2 | {
"file_name": "ulib/FStar.Reflection.V2.Arith.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 34,
"end_line": 68,
"start_col": 0,
"start_line": 68
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.c... | [
{
"abbrev": true,
"full_module": "FStar.Order",
"short_module": "O"
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | e1: FStar.Reflection.V2.Arith.expr -> e2: FStar.Reflection.V2.Arith.expr
-> FStar.Reflection.V2.Arith.prop | Prims.Tot | [
"total"
] | [] | [
"FStar.Reflection.V2.Arith.expr",
"FStar.Reflection.V2.Arith.CompProp",
"FStar.Reflection.V2.Arith.C_Ne",
"FStar.Reflection.V2.Arith.prop"
] | [] | false | false | false | true | false | let ne e1 e2 =
| CompProp e1 C_Ne e2 | false | |
FStar.Reflection.V2.Arith.fst | FStar.Reflection.V2.Arith.le | val le : e1: FStar.Reflection.V2.Arith.expr -> e2: FStar.Reflection.V2.Arith.expr
-> FStar.Reflection.V2.Arith.prop | let le e1 e2 = CompProp e1 C_Lt (Plus (Lit 1) e2) | {
"file_name": "ulib/FStar.Reflection.V2.Arith.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 49,
"end_line": 66,
"start_col": 0,
"start_line": 66
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.c... | [
{
"abbrev": true,
"full_module": "FStar.Order",
"short_module": "O"
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | e1: FStar.Reflection.V2.Arith.expr -> e2: FStar.Reflection.V2.Arith.expr
-> FStar.Reflection.V2.Arith.prop | Prims.Tot | [
"total"
] | [] | [
"FStar.Reflection.V2.Arith.expr",
"FStar.Reflection.V2.Arith.CompProp",
"FStar.Reflection.V2.Arith.C_Lt",
"FStar.Reflection.V2.Arith.Plus",
"FStar.Reflection.V2.Arith.Lit",
"FStar.Reflection.V2.Arith.prop"
] | [] | false | false | false | true | false | let le e1 e2 =
| CompProp e1 C_Lt (Plus (Lit 1) e2) | false | |
FStar.Reflection.V2.Arith.fst | FStar.Reflection.V2.Arith.return | val return (x: 'a) : tm 'a | val return (x: 'a) : tm 'a | let return (x:'a) : tm 'a = fun i -> Inr (x, i) | {
"file_name": "ulib/FStar.Reflection.V2.Arith.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 55,
"end_line": 75,
"start_col": 8,
"start_line": 75
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.c... | [
{
"abbrev": true,
"full_module": "FStar.Order",
"short_module": "O"
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: 'a -> FStar.Reflection.V2.Arith.tm 'a | Prims.Tot | [
"total"
] | [] | [
"FStar.Reflection.V2.Arith.st",
"FStar.Pervasives.Inr",
"Prims.string",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.either",
"FStar.Reflection.V2.Arith.tm"
] | [] | false | false | false | true | false | let return (x: 'a) : tm 'a =
| fun i -> Inr (x, i) | false |
Vale.Lib.Seqs.fst | Vale.Lib.Seqs.lemma_list_to_seq | val lemma_list_to_seq (#a:Type) (l:list a) : Lemma
(ensures norm [zeta; iota; delta_only [`%list_to_seq_post]] (list_to_seq_post l (list_to_seq l) 0)) | val lemma_list_to_seq (#a:Type) (l:list a) : Lemma
(ensures norm [zeta; iota; delta_only [`%list_to_seq_post]] (list_to_seq_post l (list_to_seq l) 0)) | let lemma_list_to_seq #a l =
lemma_list_to_seq_rec l (list_to_seq l) 0 | {
"file_name": "vale/code/lib/collections/Vale.Lib.Seqs.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 43,
"end_line": 123,
"start_col": 0,
"start_line": 122
} | module Vale.Lib.Seqs
open FStar.Mul
let lemma_slice_first_exactly_in_append (#a:Type) (x y:seq a) :
Lemma (slice (append x y) 0 (length x) == x) =
let xy = append x y in
let xy_slice = slice xy 0 (length x) in
let x_slice = slice x 0 (length x) in
assert(equal xy_slice x_slice); // OBSERVE: extensionality
... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.Seqs.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | l: Prims.list a
-> FStar.Pervasives.Lemma
(ensures
FStar.Pervasives.norm [
FStar.Pervasives.zeta;
FStar.Pervasives.iota;
FStar.Pervasives.delta_only ["Vale.Lib.Seqs.list_to_seq_post"]
]
(Vale.Lib.Seqs.list_to_seq_post l (Vale.Lib.Seqs.list_to_seq l) 0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Vale.Lib.Seqs.lemma_list_to_seq_rec",
"Vale.Lib.Seqs.list_to_seq",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_list_to_seq #a l =
| lemma_list_to_seq_rec l (list_to_seq l) 0 | false |
FStar.Reflection.V2.Arith.fst | FStar.Reflection.V2.Arith.gt | val gt : e1: FStar.Reflection.V2.Arith.expr -> e2: FStar.Reflection.V2.Arith.expr
-> FStar.Reflection.V2.Arith.prop | let gt e1 e2 = CompProp e1 C_Gt e2 | {
"file_name": "ulib/FStar.Reflection.V2.Arith.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 34,
"end_line": 69,
"start_col": 0,
"start_line": 69
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.c... | [
{
"abbrev": true,
"full_module": "FStar.Order",
"short_module": "O"
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | e1: FStar.Reflection.V2.Arith.expr -> e2: FStar.Reflection.V2.Arith.expr
-> FStar.Reflection.V2.Arith.prop | Prims.Tot | [
"total"
] | [] | [
"FStar.Reflection.V2.Arith.expr",
"FStar.Reflection.V2.Arith.CompProp",
"FStar.Reflection.V2.Arith.C_Gt",
"FStar.Reflection.V2.Arith.prop"
] | [] | false | false | false | true | false | let gt e1 e2 =
| CompProp e1 C_Gt e2 | false | |
FStar.Reflection.V2.Arith.fst | FStar.Reflection.V2.Arith.tm | val tm : a: Type -> Type0 | let tm a = st -> Tac (either string (a * st)) | {
"file_name": "ulib/FStar.Reflection.V2.Arith.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 53,
"end_line": 74,
"start_col": 8,
"start_line": 74
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.c... | [
{
"abbrev": true,
"full_module": "FStar.Order",
"short_module": "O"
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Type -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Reflection.V2.Arith.st",
"FStar.Pervasives.either",
"Prims.string",
"FStar.Pervasives.Native.tuple2"
] | [] | false | false | false | true | true | let tm a =
| st -> Tac (either string (a * st)) | false | |
FStar.Reflection.V2.Arith.fst | FStar.Reflection.V2.Arith.ge | val ge : e1: FStar.Reflection.V2.Arith.expr -> e2: FStar.Reflection.V2.Arith.expr
-> FStar.Reflection.V2.Arith.prop | let ge e1 e2 = CompProp (Plus (Lit 1) e1) C_Gt e2 | {
"file_name": "ulib/FStar.Reflection.V2.Arith.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 49,
"end_line": 70,
"start_col": 0,
"start_line": 70
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.c... | [
{
"abbrev": true,
"full_module": "FStar.Order",
"short_module": "O"
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | e1: FStar.Reflection.V2.Arith.expr -> e2: FStar.Reflection.V2.Arith.expr
-> FStar.Reflection.V2.Arith.prop | Prims.Tot | [
"total"
] | [] | [
"FStar.Reflection.V2.Arith.expr",
"FStar.Reflection.V2.Arith.CompProp",
"FStar.Reflection.V2.Arith.Plus",
"FStar.Reflection.V2.Arith.Lit",
"FStar.Reflection.V2.Arith.C_Gt",
"FStar.Reflection.V2.Arith.prop"
] | [] | false | false | false | true | false | let ge e1 e2 =
| CompProp (Plus (Lit 1) e1) C_Gt e2 | false | |
FStar.Reflection.V2.Arith.fst | FStar.Reflection.V2.Arith.st | val st : Type0 | let st = p:(nat * list term){fst p == List.Tot.Base.length (snd p)} | {
"file_name": "ulib/FStar.Reflection.V2.Arith.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 75,
"end_line": 73,
"start_col": 8,
"start_line": 73
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.c... | [
{
"abbrev": true,
"full_module": "FStar.Order",
"short_module": "O"
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Native.tuple2",
"Prims.nat",
"Prims.list",
"FStar.Stubs.Reflection.Types.term",
"Prims.eq2",
"FStar.Pervasives.Native.fst",
"FStar.List.Tot.Base.length",
"FStar.Pervasives.Native.snd"
] | [] | false | false | false | true | true | let st =
| p: (nat * list term){fst p == List.Tot.Base.length (snd p)} | false | |
FStar.Reflection.V2.Arith.fst | FStar.Reflection.V2.Arith.lift | val lift : ('a -> Tac 'b) -> ('a -> tm 'b) | val lift : ('a -> Tac 'b) -> ('a -> tm 'b) | let lift f x st =
Inr (f x, st) | {
"file_name": "ulib/FStar.Reflection.V2.Arith.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 17,
"end_line": 83,
"start_col": 0,
"start_line": 82
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.c... | [
{
"abbrev": true,
"full_module": "FStar.Order",
"short_module": "O"
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: 'a -> FStar.Tactics.Effect.Tac 'b) -> _: 'a -> FStar.Reflection.V2.Arith.tm 'b | Prims.Tot | [
"total"
] | [] | [
"FStar.Reflection.V2.Arith.st",
"FStar.Pervasives.Inr",
"Prims.string",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.either",
"FStar.Pervasives.Native.Mktuple2"
] | [] | false | false | false | false | false | let lift f x st =
| Inr (f x, st) | false |
FStar.Reflection.V2.Arith.fst | FStar.Reflection.V2.Arith.liftM3 | val liftM3 : ('a -> 'b -> 'c -> 'd) -> (tm 'a -> tm 'b -> tm 'c -> tm 'd) | val liftM3 : ('a -> 'b -> 'c -> 'd) -> (tm 'a -> tm 'b -> tm 'c -> tm 'd) | let liftM3 f x y z =
let! xx = x in
let! yy = y in
let! zz = z in
return (f xx yy zz) | {
"file_name": "ulib/FStar.Reflection.V2.Arith.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 23,
"end_line": 101,
"start_col": 0,
"start_line": 97
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.c... | [
{
"abbrev": true,
"full_module": "FStar.Order",
"short_module": "O"
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
f: (_: 'a -> _: 'b -> _: 'c -> 'd) ->
_: FStar.Reflection.V2.Arith.tm 'a ->
_: FStar.Reflection.V2.Arith.tm 'b ->
_: FStar.Reflection.V2.Arith.tm 'c
-> FStar.Reflection.V2.Arith.tm 'd | Prims.Tot | [
"total"
] | [] | [
"FStar.Reflection.V2.Arith.tm",
"FStar.Reflection.V2.Arith.op_let_Bang",
"FStar.Reflection.V2.Arith.return"
] | [] | false | false | false | true | false | let liftM3 f x y z =
| let! xx = x in
let! yy = y in
let! zz = z in
return (f xx yy zz) | false |
FStar.Reflection.V2.Arith.fst | FStar.Reflection.V2.Arith.liftM | val liftM : ('a -> 'b) -> (tm 'a -> tm 'b) | val liftM : ('a -> 'b) -> (tm 'a -> tm 'b) | let liftM f x =
let! xx = x in
return (f xx) | {
"file_name": "ulib/FStar.Reflection.V2.Arith.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 17,
"end_line": 88,
"start_col": 0,
"start_line": 86
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.c... | [
{
"abbrev": true,
"full_module": "FStar.Order",
"short_module": "O"
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: 'a -> 'b) -> _: FStar.Reflection.V2.Arith.tm 'a -> FStar.Reflection.V2.Arith.tm 'b | Prims.Tot | [
"total"
] | [] | [
"FStar.Reflection.V2.Arith.tm",
"FStar.Reflection.V2.Arith.op_let_Bang",
"FStar.Reflection.V2.Arith.return"
] | [] | false | false | false | true | false | let liftM f x =
| let! xx = x in
return (f xx) | false |
Tutorial.fst | Tutorial.ex3 | val ex3 : x: Prims.nat -> Prims.unit | let ex3 (x : nat) =
assert_by_tactic (x + x >= 0 /\ List.length [4;5;1] == 3) tau3 | {
"file_name": "examples/tactics/Tutorial.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 64,
"end_line": 115,
"start_col": 0,
"start_line": 114
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.fst.checked"
],
"interface_file": false,
"source_file": "Tutorial.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.List",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.nat -> Prims.unit | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Prims.op_Addition",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"Prims.Cons",
"Prims.Nil",
"Tutorial.tau3",
"Prims.unit"
] | [] | false | false | false | true | false | let ex3 (x: nat) =
| assert_by_tactic (x + x >= 0 /\ List.length [4; 5; 1] == 3) tau3 | false | |
FStar.Reflection.V2.Arith.fst | FStar.Reflection.V2.Arith.fail | val fail : (#a:Type) -> string -> tm a | val fail : (#a:Type) -> string -> tm a | let fail #a s = fun i -> Inl s | {
"file_name": "ulib/FStar.Reflection.V2.Arith.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 121,
"start_col": 8,
"start_line": 121
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.c... | [
{
"abbrev": true,
"full_module": "FStar.Order",
"short_module": "O"
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s: Prims.string -> FStar.Reflection.V2.Arith.tm a | Prims.Tot | [
"total"
] | [] | [
"Prims.string",
"FStar.Reflection.V2.Arith.st",
"FStar.Pervasives.Inl",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.either"
] | [] | false | false | false | true | false | let fail #a s =
| fun i -> Inl s | false |
FStar.Reflection.V2.Arith.fst | FStar.Reflection.V2.Arith.liftM2 | val liftM2 : ('a -> 'b -> 'c) -> (tm 'a -> tm 'b -> tm 'c) | val liftM2 : ('a -> 'b -> 'c) -> (tm 'a -> tm 'b -> tm 'c) | let liftM2 f x y =
let! xx = x in
let! yy = y in
return (f xx yy) | {
"file_name": "ulib/FStar.Reflection.V2.Arith.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 20,
"end_line": 94,
"start_col": 0,
"start_line": 91
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.c... | [
{
"abbrev": true,
"full_module": "FStar.Order",
"short_module": "O"
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
f: (_: 'a -> _: 'b -> 'c) ->
_: FStar.Reflection.V2.Arith.tm 'a ->
_: FStar.Reflection.V2.Arith.tm 'b
-> FStar.Reflection.V2.Arith.tm 'c | Prims.Tot | [
"total"
] | [] | [
"FStar.Reflection.V2.Arith.tm",
"FStar.Reflection.V2.Arith.op_let_Bang",
"FStar.Reflection.V2.Arith.return"
] | [] | false | false | false | true | false | let liftM2 f x y =
| let! xx = x in
let! yy = y in
return (f xx yy) | false |
FStar.Reflection.V2.Arith.fst | FStar.Reflection.V2.Arith.is_arith_prop | val is_arith_prop : term -> st -> Tac (either string (prop * st)) | val is_arith_prop : term -> st -> Tac (either string (prop * st)) | let rec is_arith_prop (t:term) = fun i ->
(let! f = lift (fun t -> term_as_formula t) t in
match f with
| Comp (Eq _) l r -> liftM2 eq (is_arith_expr l) (is_arith_expr r)
| Comp (BoolEq _) l r -> liftM2 eq (is_arith_expr l) (is_arith_expr r)
| Comp Lt l r -> liftM2 lt (is_arith_expr l) (is_ar... | {
"file_name": "ulib/FStar.Reflection.V2.Arith.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 41,
"end_line": 207,
"start_col": 0,
"start_line": 196
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.c... | [
{
"abbrev": true,
"full_module": "FStar.Order",
"short_module": "O"
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | t: FStar.Stubs.Reflection.Types.term -> i: FStar.Reflection.V2.Arith.st
-> FStar.Tactics.Effect.Tac
(FStar.Pervasives.either Prims.string
(FStar.Reflection.V2.Arith.prop * FStar.Reflection.V2.Arith.st)) | FStar.Tactics.Effect.Tac | [] | [] | [
"FStar.Stubs.Reflection.Types.term",
"FStar.Reflection.V2.Arith.st",
"FStar.Reflection.V2.Arith.op_let_Bang",
"FStar.Reflection.V2.Formula.formula",
"FStar.Reflection.V2.Arith.prop",
"FStar.Reflection.V2.Arith.lift",
"FStar.Tactics.NamedView.term",
"FStar.Reflection.V2.Formula.term_as_formula",
"FSt... | [
"recursion"
] | false | true | false | false | false | let rec is_arith_prop (t: term) =
| fun i ->
(let! f = lift (fun t -> term_as_formula t) t in
match f with
| Comp (Eq _) l r -> liftM2 eq (is_arith_expr l) (is_arith_expr r)
| Comp (BoolEq _) l r -> liftM2 eq (is_arith_expr l) (is_arith_expr r)
| Comp Lt l r -> liftM2 lt (is_arith_expr l) (is_arith_expr r)
| Comp Le l r -> liftM2 le... | false |
FStar.Reflection.V2.Arith.fst | FStar.Reflection.V2.Arith.is_arith_expr | val is_arith_expr : term -> tm expr | val is_arith_expr : term -> tm expr | let is_arith_expr t =
let! a = as_arith_expr t in
match a with
| Atom _ t -> begin
let hd, tl = collect_app_ref t in
match inspect_ln hd, tl with
| Tv_FVar _, []
| Tv_BVar _, []
| Tv_Var _, [] -> return a
| _ -> let! s = lift term_to_string t in
fail ("not an arithmetic expressi... | {
"file_name": "ulib/FStar.Reflection.V2.Arith.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 17,
"end_line": 191,
"start_col": 0,
"start_line": 179
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.c... | [
{
"abbrev": true,
"full_module": "FStar.Order",
"short_module": "O"
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | t: FStar.Stubs.Reflection.Types.term -> FStar.Reflection.V2.Arith.tm FStar.Reflection.V2.Arith.expr | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.term",
"FStar.Reflection.V2.Arith.op_let_Bang",
"FStar.Reflection.V2.Arith.expr",
"FStar.Reflection.V2.Arith.as_arith_expr",
"Prims.nat",
"Prims.l_or",
"Prims.eq2",
"Prims.precedes",
"Prims.list",
"FStar.Stubs.Reflection.V2.Data.argv",
"FStar.Pervasives.Native.fst",... | [] | false | false | false | true | false | let is_arith_expr t =
| let! a = as_arith_expr t in
match a with
| Atom _ t ->
let hd, tl = collect_app_ref t in
(match inspect_ln hd, tl with
| Tv_FVar _, [] | Tv_BVar _, [] | Tv_Var _, [] -> return a
| _ ->
let! s = lift term_to_string t in
fail ("not an arithmetic expression: (" ^ s ^ ")"))
| _ -> return a | false |
Tutorial.fst | Tutorial.ex4 | val ex4 : x: Prims.nat -> Prims.unit | let ex4 (x : nat) =
assert_by_tactic
((1 + 1 == 2) /\
((-x <= 0 /\ x + x >= 0) /\
List.length [4;5;1] == 3))
split_all | {
"file_name": "examples/tactics/Tutorial.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 13,
"end_line": 197,
"start_col": 0,
"start_line": 192
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.fst.checked"
],
"interface_file": false,
"source_file": "Tutorial.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.List",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.nat -> Prims.unit | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.l_and",
"Prims.eq2",
"Prims.int",
"Prims.op_Addition",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Minus",
"Prims.op_GreaterThanOrEqual",
"FStar.List.Tot.Base.length",
"Prims.Cons",
"Prims.Nil",
"Tutorial.split_all",
"Pr... | [] | false | false | false | true | false | let ex4 (x: nat) =
| assert_by_tactic ((1 + 1 == 2) /\ ((- x <= 0 /\ x + x >= 0) /\ List.length [4; 5; 1] == 3))
split_all | false | |
Tutorial.fst | Tutorial.ex3' | val ex3' : x: Prims.nat -> Prims.unit | let ex3' (x : nat) =
assert_by_tactic (x + x >= 0 /\ List.length [4;5;1] == 3)
split_all | {
"file_name": "examples/tactics/Tutorial.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 190,
"start_col": 0,
"start_line": 188
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.fst.checked"
],
"interface_file": false,
"source_file": "Tutorial.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.List",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.nat -> Prims.unit | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Prims.op_Addition",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"Prims.Cons",
"Prims.Nil",
"Tutorial.split_all",
"Prims.unit"
] | [] | false | false | false | true | false | let ex3' (x: nat) =
| assert_by_tactic (x + x >= 0 /\ List.length [4; 5; 1] == 3) split_all | false | |
Vale.Lib.Seqs.fst | Vale.Lib.Seqs.lemma_list_to_seq_rec | val lemma_list_to_seq_rec (#a: Type) (l: list a) (s: seq a) (n: nat)
: Lemma
(requires
n + List.length l == Seq.length s /\
Seq.equal (Seq.slice s n (Seq.length s)) (list_to_seq l))
(ensures list_to_seq_post l s n)
(decreases l) | val lemma_list_to_seq_rec (#a: Type) (l: list a) (s: seq a) (n: nat)
: Lemma
(requires
n + List.length l == Seq.length s /\
Seq.equal (Seq.slice s n (Seq.length s)) (list_to_seq l))
(ensures list_to_seq_post l s n)
(decreases l) | let rec lemma_list_to_seq_rec (#a:Type) (l:list a) (s:seq a) (n:nat) : Lemma
(requires n + List.length l == Seq.length s /\ Seq.equal (Seq.slice s n (Seq.length s)) (list_to_seq l))
(ensures list_to_seq_post l s n)
(decreases l)
=
match l with
| [] -> ()
| h::t ->
let lem (i:nat) : Lemma
(requir... | {
"file_name": "vale/code/lib/collections/Vale.Lib.Seqs.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 6,
"end_line": 120,
"start_col": 0,
"start_line": 95
} | module Vale.Lib.Seqs
open FStar.Mul
let lemma_slice_first_exactly_in_append (#a:Type) (x y:seq a) :
Lemma (slice (append x y) 0 (length x) == x) =
let xy = append x y in
let xy_slice = slice xy 0 (length x) in
let x_slice = slice x 0 (length x) in
assert(equal xy_slice x_slice); // OBSERVE: extensionality
... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.Seqs.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | l: Prims.list a -> s: FStar.Seq.Base.seq a -> n: Prims.nat
-> FStar.Pervasives.Lemma
(requires
n + FStar.List.Tot.Base.length l == FStar.Seq.Base.length s /\
FStar.Seq.Base.equal (FStar.Seq.Base.slice s n (FStar.Seq.Base.length s))
(Vale.Lib.Seqs.list_to_seq l))
(ensures Vale.Lib... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"Prims.list",
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"FStar.Seq.Base.index",
"Vale.Lib.Seqs.list_to_seq",
"Vale.Lib.Seqs.lemma_list_to_seq_rec",
"Prims.op_Addition",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.List.Tot.Base.length",
"Prims.squash",
"F... | [
"recursion"
] | false | false | true | false | false | let rec lemma_list_to_seq_rec (#a: Type) (l: list a) (s: seq a) (n: nat)
: Lemma
(requires
n + List.length l == Seq.length s /\
Seq.equal (Seq.slice s n (Seq.length s)) (list_to_seq l))
(ensures list_to_seq_post l s n)
(decreases l) =
| match l with
| [] -> ()
| h :: t ->
let lem (i: nat)
: Lemma (requires i < List.length t)
(ensures Seq.index (Seq.slice s (n + 1) (Seq.length s)) i == Seq.index (list_to_seq t) i)
[SMTPat (Seq.index (list_to_seq t) i)] =
calc ( == ) {
Seq.index (Seq.slice s (n + 1) (Seq.length s)) i;
... | false |
Hacl.Impl.Box.fst | Hacl.Impl.Box.box_beforenm | val box_beforenm:
k:lbuffer uint8 32ul
-> pk:lbuffer uint8 32ul
-> sk:lbuffer uint8 32ul ->
Stack size_t
(requires fun h -> live h k /\ live h pk /\ live h sk /\
disjoint k pk /\ disjoint k sk)
(ensures fun h0 r h1 -> modifies (loc k) h0 h1 /\
(let key = Spec.box_beforenm (as_seq h0 pk) (as_seq h0... | val box_beforenm:
k:lbuffer uint8 32ul
-> pk:lbuffer uint8 32ul
-> sk:lbuffer uint8 32ul ->
Stack size_t
(requires fun h -> live h k /\ live h pk /\ live h sk /\
disjoint k pk /\ disjoint k sk)
(ensures fun h0 r h1 -> modifies (loc k) h0 h1 /\
(let key = Spec.box_beforenm (as_seq h0 pk) (as_seq h0... | let box_beforenm k pk sk =
push_frame();
let n0 = create 16ul (u8 0) in
let r = Hacl.Curve25519_51.ecdh k sk pk in
let res =
if r then (
Hacl.Salsa20.hsalsa20 k k n0;
0ul)
else
0xfffffffful in
pop_frame();
res | {
"file_name": "code/nacl-box/Hacl.Impl.Box.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 46,
"start_col": 0,
"start_line": 35
} | module Hacl.Impl.Box
open FStar.HyperStack.All
open FStar.HyperStack
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Hacl.Impl.SecretBox
module ST = FStar.HyperStack.ST
module Spec = Spec.Box
module LSeq = Lib.Sequence
#set-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
val box_bef... | {
"checked_file": "/",
"dependencies": [
"Spec.Box.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Salsa20.fst.checked",
"Hacl.Impl.SecretBox.fst.checked",
"Hacl.Curve2551... | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Spec.Box",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
k: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul ->
pk: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul ->
sk: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul
-> FStar.HyperStack.ST.Stack Lib.IntTypes.size_t | FStar.HyperStack.ST.Stack | [] | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.size_t",
"Prims.unit",
"FStar.HyperStack.ST.pop_frame",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Salsa20.hsalsa20",
"Prims.bool",
"Hacl.Curve25519_51.ecdh",
"Lib.Buffer.lbuffer_t"... | [] | false | true | false | false | false | let box_beforenm k pk sk =
| push_frame ();
let n0 = create 16ul (u8 0) in
let r = Hacl.Curve25519_51.ecdh k sk pk in
let res =
if r
then
(Hacl.Salsa20.hsalsa20 k k n0;
0ul)
else 0xfffffffful
in
pop_frame ();
res | false |
FStar.Reflection.V2.Arith.fst | FStar.Reflection.V2.Arith.compare_expr | val compare_expr (e1 e2: expr) : O.order | val compare_expr (e1 e2: expr) : O.order | let rec compare_expr (e1 e2 : expr) : O.order =
match e1, e2 with
| Lit i, Lit j -> O.compare_int i j
| Atom _ t, Atom _ s -> compare_term t s
| Plus l1 l2, Plus r1 r2
| Minus l1 l2, Minus r1 r2
| Mult l1 l2, Mult r1 r2 -> O.lex (compare_expr l1 r1) (fun () -> compare_expr l2 r2)
| Neg e1, N... | {
"file_name": "ulib/FStar.Reflection.V2.Arith.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 15,
"end_line": 249,
"start_col": 0,
"start_line": 236
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.c... | [
{
"abbrev": true,
"full_module": "FStar.Order",
"short_module": "O"
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | e1: FStar.Reflection.V2.Arith.expr -> e2: FStar.Reflection.V2.Arith.expr -> FStar.Order.order | Prims.Tot | [
"total"
] | [] | [
"FStar.Reflection.V2.Arith.expr",
"FStar.Pervasives.Native.Mktuple2",
"Prims.int",
"FStar.Order.compare_int",
"Prims.nat",
"FStar.Stubs.Reflection.Types.term",
"FStar.Reflection.V2.Compare.compare_term",
"FStar.Order.lex",
"FStar.Reflection.V2.Arith.compare_expr",
"Prims.unit",
"FStar.Order.orde... | [
"recursion"
] | false | false | false | true | false | let rec compare_expr (e1 e2: expr) : O.order =
| match e1, e2 with
| Lit i, Lit j -> O.compare_int i j
| Atom _ t, Atom _ s -> compare_term t s
| Plus l1 l2, Plus r1 r2
| Minus l1 l2, Minus r1 r2
| Mult l1 l2, Mult r1 r2 -> O.lex (compare_expr l1 r1) (fun () -> compare_expr l2 r2)
| Neg e1, Neg e2 -> compare_expr e1 e2
| Lit _, _ -> O.Lt
| _, Lit _ -> O.Gt
| Atom _ _... | false |
FStar.Reflection.V2.Arith.fst | FStar.Reflection.V2.Arith.run_tm | val run_tm (m: tm 'a) : Tac (either string 'a) | val run_tm (m: tm 'a) : Tac (either string 'a) | let run_tm (m : tm 'a) : Tac (either string 'a) =
match m (0, []) with
| Inr (x, _) -> Inr x
| s -> Inl (Inl?.v s) | {
"file_name": "ulib/FStar.Reflection.V2.Arith.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 25,
"end_line": 214,
"start_col": 0,
"start_line": 211
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.c... | [
{
"abbrev": true,
"full_module": "FStar.Order",
"short_module": "O"
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | m: FStar.Reflection.V2.Arith.tm 'a
-> FStar.Tactics.Effect.Tac (FStar.Pervasives.either Prims.string 'a) | FStar.Tactics.Effect.Tac | [] | [] | [
"FStar.Reflection.V2.Arith.tm",
"FStar.Reflection.V2.Arith.st",
"FStar.Pervasives.Inr",
"Prims.string",
"FStar.Pervasives.either",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Inl",
"FStar.Pervasives.__proj__Inl__item__v",
"FStar.Pervasives.Native.Mktuple2",
"Prims.nat",
"Prims.list",
"... | [] | false | true | false | false | false | let run_tm (m: tm 'a) : Tac (either string 'a) =
| match m (0, []) with
| Inr (x, _) -> Inr x
| s -> Inl (Inl?.v s) | false |
FStar.Reflection.V2.Arith.fst | FStar.Reflection.V2.Arith.atom | val atom (t: term) : tm expr | val atom (t: term) : tm expr | let atom (t:term) : tm expr = fun (n, atoms) ->
match find_idx (term_eq_old t) atoms with
| None -> Inr (Atom n t, (n + 1, t::atoms))
| Some (i, t) -> Inr (Atom (n - 1 - i) t, (n, atoms)) | {
"file_name": "ulib/FStar.Reflection.V2.Arith.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 57,
"end_line": 118,
"start_col": 8,
"start_line": 115
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.c... | [
{
"abbrev": true,
"full_module": "FStar.Order",
"short_module": "O"
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | t: FStar.Stubs.Reflection.Types.term -> FStar.Reflection.V2.Arith.tm FStar.Reflection.V2.Arith.expr | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.term",
"FStar.Reflection.V2.Arith.st",
"Prims.nat",
"Prims.list",
"FStar.Pervasives.Inr",
"Prims.string",
"FStar.Pervasives.Native.tuple2",
"FStar.Reflection.V2.Arith.expr",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Reflection.V2.Arith.Atom",
"Prims.op_Addition",
... | [] | false | false | false | true | false | let atom (t: term) : tm expr =
| fun (n, atoms) ->
match find_idx (term_eq_old t) atoms with
| None -> Inr (Atom n t, (n + 1, t :: atoms))
| Some (i, t) -> Inr (Atom (n - 1 - i) t, (n, atoms)) | false |
FStar.Reflection.V2.Arith.fst | FStar.Reflection.V2.Arith.find_idx | val find_idx (f: ('a -> Tac bool)) (l: list 'a)
: Tac (option ((n: nat{n < List.Tot.Base.length l}) * 'a)) | val find_idx (f: ('a -> Tac bool)) (l: list 'a)
: Tac (option ((n: nat{n < List.Tot.Base.length l}) * 'a)) | let rec find_idx (f : 'a -> Tac bool) (l : list 'a) : Tac (option ((n:nat{n < List.Tot.Base.length l}) * 'a)) =
match l with
| [] -> None
| x::xs ->
if f x
then Some (0, x)
else begin match find_idx f xs with
| None -> None
| Some (i, x) -> Some (i+1, x)
... | {
"file_name": "ulib/FStar.Reflection.V2.Arith.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 16,
"end_line": 113,
"start_col": 8,
"start_line": 104
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.c... | [
{
"abbrev": true,
"full_module": "FStar.Order",
"short_module": "O"
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: 'a -> FStar.Tactics.Effect.Tac Prims.bool) -> l: Prims.list 'a
-> FStar.Tactics.Effect.Tac
(FStar.Pervasives.Native.option (n: Prims.nat{n < FStar.List.Tot.Base.length l} * 'a)) | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.bool",
"Prims.list",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.tuple2",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.List.Tot.Base.length",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.Mktuple2",
"Prims.op_Addition",
... | [
"recursion"
] | false | true | false | false | false | let rec find_idx (f: ('a -> Tac bool)) (l: list 'a)
: Tac (option ((n: nat{n < List.Tot.Base.length l}) * 'a)) =
| match l with
| [] -> None
| x :: xs ->
if f x
then Some (0, x)
else
match find_idx f xs with
| None -> None
| Some (i, x) -> Some (i + 1, x) | false |
FStar.Reflection.V2.Arith.fst | FStar.Reflection.V2.Arith.as_arith_expr | val as_arith_expr : term -> tm expr | val as_arith_expr : term -> tm expr | let rec as_arith_expr (t:term) =
let hd, tl = collect_app_ln t in
// Invoke [collect_app_order]: forall (arg, qual) ∈ tl, (arg, qual) << t
collect_app_order t;
// [precedes_fst_tl]: forall (arg, qual) ∈ tl, arg << t
let precedes_fst_tl (arg: term) (q: aqualv)
: Lemma (List.Tot.memP (arg, q) tl... | {
"file_name": "ulib/FStar.Reflection.V2.Arith.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 14,
"end_line": 175,
"start_col": 0,
"start_line": 125
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.c... | [
{
"abbrev": true,
"full_module": "FStar.Order",
"short_module": "O"
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 4,
"initial_ifuel": 1,
"max_fuel": 4,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | t: FStar.Stubs.Reflection.Types.term -> FStar.Reflection.V2.Arith.tm FStar.Reflection.V2.Arith.expr | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.term",
"Prims.list",
"FStar.Stubs.Reflection.V2.Data.argv",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Stubs.Reflection.V2.Data.term_view",
"FStar.Pervasives.Native.tuple2",
"FStar.Stubs.Reflection.V2.Data.aqualv",
"FStar.Stubs.Reflection.V2.Builtins.inspect_ln",
"FStar... | [
"recursion"
] | false | false | false | true | false | let rec as_arith_expr (t: term) =
| let hd, tl = collect_app_ln t in
collect_app_order t;
let precedes_fst_tl (arg: term) (q: aqualv) : Lemma (List.Tot.memP (arg, q) tl ==> arg << t) =
let _:argv = arg, q in
()
in
Classical.forall_intro_2 (precedes_fst_tl);
match inspect_ln hd, tl with
| Tv_FVar fv, [e1, Q_Implicit ; e2, Q_Explicit ; e3, Q_Explicit] ... | false |
FStar.Reflection.V2.Arith.fst | FStar.Reflection.V2.Arith.expr_to_string | val expr_to_string (e: expr) : string | val expr_to_string (e: expr) : string | let rec expr_to_string (e:expr) : string =
match e with
| Atom i _ -> "a"^(string_of_int i)
| Lit i -> string_of_int i
| Plus l r -> "(" ^ (expr_to_string l) ^ " + " ^ (expr_to_string r) ^ ")"
| Minus l r -> "(" ^ (expr_to_string l) ^ " - " ^ (expr_to_string r) ^ ")"
| Mult l r -> "(" ^ (expr_to... | {
"file_name": "ulib/FStar.Reflection.V2.Arith.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 80,
"end_line": 234,
"start_col": 0,
"start_line": 216
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.c... | [
{
"abbrev": true,
"full_module": "FStar.Order",
"short_module": "O"
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | e: FStar.Reflection.V2.Arith.expr -> Prims.string | Prims.Tot | [
"total"
] | [] | [
"FStar.Reflection.V2.Arith.expr",
"Prims.nat",
"FStar.Stubs.Reflection.Types.term",
"Prims.op_Hat",
"Prims.string_of_int",
"Prims.int",
"FStar.Reflection.V2.Arith.expr_to_string",
"Prims.string"
] | [
"recursion"
] | false | false | false | true | false | let rec expr_to_string (e: expr) : string =
| match e with
| Atom i _ -> "a" ^ (string_of_int i)
| Lit i -> string_of_int i
| Plus l r -> "(" ^ (expr_to_string l) ^ " + " ^ (expr_to_string r) ^ ")"
| Minus l r -> "(" ^ (expr_to_string l) ^ " - " ^ (expr_to_string r) ^ ")"
| Mult l r -> "(" ^ (expr_to_string l) ^ " * " ^ (expr_to_string r) ^ ")"
| Neg l -> "(- " ^ ... | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.eternal_region_pred | val eternal_region_pred (m1 m2: mem) : Type0 | val eternal_region_pred (m1 m2: mem) : Type0 | let eternal_region_pred (m1 m2:mem) :Type0
= forall (r:HS.rid).{:pattern (HS.is_heap_color (color r)); (m1 `contains_region` r)}
(HS.is_eternal_region_hs r /\ m1 `contains_region` r) ==> m2 `contains_region` r | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 97,
"end_line": 28,
"start_col": 8,
"start_line": 26
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | m1: FStar.Monotonic.HyperStack.mem -> m2: FStar.Monotonic.HyperStack.mem -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"Prims.l_Forall",
"FStar.Monotonic.HyperHeap.rid",
"Prims.l_imp",
"Prims.l_and",
"Prims.b2t",
"FStar.Monotonic.HyperStack.is_eternal_region_hs",
"FStar.HyperStack.ST.contains_region",
"FStar.Monotonic.HyperStack.is_heap_color",
"FStar.Monotonic.HyperHeap.color"
] | [] | false | false | false | true | true | let eternal_region_pred (m1 m2: mem) : Type0 =
| forall (r: HS.rid). {:pattern (HS.is_heap_color (color r)); (m1 `contains_region` r)}
(HS.is_eternal_region_hs r /\ m1 `contains_region` r) ==> m2 `contains_region` r | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.rid_ctr_pred | val rid_ctr_pred (m1 m2: mem) : Type0 | val rid_ctr_pred (m1 m2: mem) : Type0 | let rid_ctr_pred (m1 m2:mem) :Type0 = get_rid_ctr m1 <= get_rid_ctr m2 | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 78,
"end_line": 31,
"start_col": 8,
"start_line": 31
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | m1: FStar.Monotonic.HyperStack.mem -> m2: FStar.Monotonic.HyperStack.mem -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Monotonic.HyperStack.get_rid_ctr"
] | [] | false | false | false | true | true | let rid_ctr_pred (m1 m2: mem) : Type0 =
| get_rid_ctr m1 <= get_rid_ctr m2 | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.rid_last_component_pred | val rid_last_component_pred (m1 m2: mem) : Type0 | val rid_last_component_pred (m1 m2: mem) : Type0 | let rid_last_component_pred (m1 m2:mem) :Type0
= forall (r:HS.rid).{:pattern (m1 `contains_region` r)}
((~ (m1 `contains_region` r)) /\ rid_last_component r < get_rid_ctr m1) ==>
(~ (m2 `contains_region` r)) | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 31,
"end_line": 43,
"start_col": 8,
"start_line": 40
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | m1: FStar.Monotonic.HyperStack.mem -> m2: FStar.Monotonic.HyperStack.mem -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"Prims.l_Forall",
"FStar.Monotonic.HyperHeap.rid",
"Prims.l_imp",
"Prims.l_and",
"Prims.l_not",
"Prims.b2t",
"FStar.HyperStack.ST.contains_region",
"Prims.op_LessThan",
"FStar.Monotonic.HyperHeap.rid_last_component",
"FStar.Monotonic.HyperStack.get_rid_ctr"
] | [] | false | false | false | true | true | let rid_last_component_pred (m1 m2: mem) : Type0 =
| forall (r: HS.rid). {:pattern (m1 `contains_region` r)}
((~(m1 `contains_region` r)) /\ rid_last_component r < get_rid_ctr m1) ==>
(~(m2 `contains_region` r)) | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.eternal_refs_pred | val eternal_refs_pred (m1 m2: mem) : Type0 | val eternal_refs_pred (m1 m2: mem) : Type0 | let eternal_refs_pred (m1 m2:mem) :Type0
= forall (a:Type) (rel:preorder a) (r:HS.mreference a rel).
{:pattern (m1 `HS.contains` r)}
(is_mm r) \/
(((m1 `HS.contains` r) /\
(HS.is_eternal_region_hs (frameOf r) \/
m2 `contains_region` (HS.frameOf r))) ==> (m2 `HS.contains` r /\ rel (H... | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 107,
"end_line": 52,
"start_col": 8,
"start_line": 46
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | m1: FStar.Monotonic.HyperStack.mem -> m2: FStar.Monotonic.HyperStack.mem -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"Prims.l_Forall",
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperStack.mreference",
"Prims.l_or",
"Prims.b2t",
"FStar.Monotonic.HyperStack.is_mm",
"Prims.l_imp",
"Prims.l_and",
"FStar.Monotonic.HyperStack.contains",
"FStar.Monotonic.HyperStack.is_eternal_regio... | [] | false | false | false | true | true | let eternal_refs_pred (m1 m2: mem) : Type0 =
| forall (a: Type) (rel: preorder a) (r: HS.mreference a rel). {:pattern (m1 `HS.contains` r)}
(is_mm r) \/
(((m1 `HS.contains` r) /\
(HS.is_eternal_region_hs (frameOf r) \/ m2 `contains_region` (HS.frameOf r))) ==>
(m2 `HS.contains` r /\ rel (HS.sel m1 r) (HS.sel m2 r))) | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.next_ref_addr_in_a_region_pred | val next_ref_addr_in_a_region_pred (m1 m2: mem) : Type0 | val next_ref_addr_in_a_region_pred (m1 m2: mem) : Type0 | let next_ref_addr_in_a_region_pred (m1 m2:mem) :Type0
= forall (r:HS.rid).{:pattern (m1 `contains_region` r)}
(m1 `contains_region` r) ==>
(if m2 `contains_region` r then
let h1 = Map.sel (HS.get_hmap m1) r in
let h2 = Map.sel (HS.get_hmap m2) r in
Heap.next_addr h1 <= Heap.next... | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 14,
"end_line": 65,
"start_col": 8,
"start_line": 58
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | m1: FStar.Monotonic.HyperStack.mem -> m2: FStar.Monotonic.HyperStack.mem -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"Prims.l_Forall",
"FStar.Monotonic.HyperHeap.rid",
"Prims.l_imp",
"Prims.b2t",
"FStar.HyperStack.ST.contains_region",
"Prims.op_LessThanOrEqual",
"FStar.Monotonic.Heap.next_addr",
"FStar.Monotonic.Heap.heap",
"FStar.Map.sel",
"FStar.Monotonic.HyperStack.get_hmap... | [] | false | false | false | true | true | let next_ref_addr_in_a_region_pred (m1 m2: mem) : Type0 =
| forall (r: HS.rid). {:pattern (m1 `contains_region` r)}
(m1 `contains_region` r) ==>
(if m2 `contains_region` r
then
let h1 = Map.sel (HS.get_hmap m1) r in
let h2 = Map.sel (HS.get_hmap m2) r in
Heap.next_addr h1 <= Heap.next_addr h2
else True) | false |
Hacl.HPKE.Curve51_CP32_SHA512.fsti | Hacl.HPKE.Curve51_CP32_SHA512.cs | val cs:S.ciphersuite | val cs:S.ciphersuite | let cs:S.ciphersuite = (DH.DH_Curve25519, Hash.SHA2_256, S.Seal AEAD.CHACHA20_POLY1305, Hash.SHA2_512) | {
"file_name": "code/hpke/Hacl.HPKE.Curve51_CP32_SHA512.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 102,
"end_line": 10,
"start_col": 0,
"start_line": 10
} | module Hacl.HPKE.Curve51_CP32_SHA512
open Hacl.Impl.HPKE
module S = Spec.Agile.HPKE
module DH = Spec.Agile.DH
module AEAD = Spec.Agile.AEAD
module Hash = Spec.Agile.Hash | {
"checked_file": "/",
"dependencies": [
"Spec.Agile.HPKE.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"Spec.Agile.DH.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"Hacl.Impl.HPKE.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.chec... | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Spec.Agile.HPKE.ciphersuite | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Native.Mktuple4",
"Spec.Agile.DH.algorithm",
"Spec.Agile.HPKE.hash_algorithm",
"Spec.Agile.HPKE.aead",
"Spec.Hash.Definitions.hash_alg",
"Spec.Agile.DH.DH_Curve25519",
"Spec.Hash.Definitions.SHA2_256",
"Spec.Agile.HPKE.Seal",
"Spec.Agile.AEAD.CHACHA20_POLY1305",
"Spec.Hash.Defini... | [] | false | false | false | true | false | let cs:S.ciphersuite =
| (DH.DH_Curve25519, Hash.SHA2_256, S.Seal AEAD.CHACHA20_POLY1305, Hash.SHA2_512) | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.unused_ref_next_addr_pred | val unused_ref_next_addr_pred (m1 m2: mem) : Type0 | val unused_ref_next_addr_pred (m1 m2: mem) : Type0 | let unused_ref_next_addr_pred (m1 m2:mem) :Type0
= forall (rid:HS.rid).{:pattern (m1 `contains_region` rid)}
(m1 `contains_region` rid) ==>
(let h1 = Map.sel (HS.get_hmap m1) rid in
(forall (a:Type0) (rel:preorder a) (r:HS.mreference a rel).{:pattern (r `HS.unused_in` m1)}
(HS.f... | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 32,
"end_line": 74,
"start_col": 8,
"start_line": 68
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | m1: FStar.Monotonic.HyperStack.mem -> m2: FStar.Monotonic.HyperStack.mem -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"Prims.l_Forall",
"FStar.Monotonic.HyperHeap.rid",
"Prims.l_imp",
"Prims.b2t",
"FStar.HyperStack.ST.contains_region",
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperStack.mreference",
"Prims.l_and",
"Prims.eq2",
"FStar.Monotonic.HyperStack.frameOf",
"FStar.M... | [] | false | false | false | true | true | let unused_ref_next_addr_pred (m1 m2: mem) : Type0 =
| forall (rid: HS.rid). {:pattern (m1 `contains_region` rid)}
(m1 `contains_region` rid) ==>
(let h1 = Map.sel (HS.get_hmap m1) rid in
(forall (a: Type0) (rel: preorder a) (r: HS.mreference a rel). {:pattern (r `HS.unused_in` m1)}
(HS.frameOf r == rid /\ r `HS.unused_in` m1 /\ HS.as_addr r < Heap.next_add... | false |
CQueue.fst | CQueue.llist_fragment_head_cons_change_phead | val llist_fragment_head_cons_change_phead
(#opened: _)
(#a: Type)
(l: Ghost.erased (list a))
(phead: ref (ccell_ptrvalue a))
(head: ccell_ptrvalue a)
(phead' : ref (ccell_ptrvalue a))
: SteelGhost unit opened
(llist_fragment_head l phead head)
(fun _ -> llist_fragment_head l phead' head)
(fun _ ... | val llist_fragment_head_cons_change_phead
(#opened: _)
(#a: Type)
(l: Ghost.erased (list a))
(phead: ref (ccell_ptrvalue a))
(head: ccell_ptrvalue a)
(phead' : ref (ccell_ptrvalue a))
: SteelGhost unit opened
(llist_fragment_head l phead head)
(fun _ -> llist_fragment_head l phead' head)
(fun _ ... | let llist_fragment_head_cons_change_phead
l phead head phead'
=
let u = elim_llist_fragment_head_cons l phead head in
let head2 : ccell_lvalue _ = head in
change_equal_slprop
(ccell head)
(ccell head2);
change_equal_slprop
(llist_fragment_head u.ll_uncons_tl u.ll_uncons_pnext u.ll_uncons_next)
... | {
"file_name": "share/steel/examples/steel/CQueue.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 39,
"end_line": 1155,
"start_col": 0,
"start_line": 1141
} | module CQueue
open CQueue.LList
#set-options "--ide_id_info_off"
//Re-define squash, since this module explicitly
//replies on proving equalities of the form `t_of v == squash p`
//which are delicate in the presence of optimizations that
//unfold `Prims.squash (p /\ q)`to _:unit{p /\ q}
//See Issue #2496
let squash (... | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"CQueue.LList.fsti.checked"
],
"interface_file": true,
"source... | [
{
"abbrev": false,
"full_module": "CQueue.LList",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
l: FStar.Ghost.erased (Prims.list a) ->
phead: Steel.Reference.ref (CQueue.Cell.ccell_ptrvalue a) ->
head: CQueue.Cell.ccell_ptrvalue a ->
phead': Steel.Reference.ref (CQueue.Cell.ccell_ptrvalue a)
-> Steel.Effect.Atomic.SteelGhost Prims.unit | Steel.Effect.Atomic.SteelGhost | [] | [] | [
"Steel.Memory.inames",
"FStar.Ghost.erased",
"Prims.list",
"Steel.Reference.ref",
"CQueue.Cell.ccell_ptrvalue",
"Steel.Effect.Atomic.change_equal_slprop",
"CQueue.llist_fragment_head",
"Prims.unit",
"CQueue.intro_llist_fragment_head_cons",
"FStar.Ghost.reveal",
"CQueue.__proj__Mkll_uncons_t__ite... | [] | false | true | false | false | false | let llist_fragment_head_cons_change_phead l phead head phead' =
| let u = elim_llist_fragment_head_cons l phead head in
let head2:ccell_lvalue _ = head in
change_equal_slprop (ccell head) (ccell head2);
change_equal_slprop (llist_fragment_head u.ll_uncons_tl u.ll_uncons_pnext u.ll_uncons_next)
(llist_fragment_head u.ll_uncons_tl (ccell_next head2) u.ll_uncons_next);
let l' = intro_... | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.mm_refs_pred | val mm_refs_pred (m1 m2: mem) : Type0 | val mm_refs_pred (m1 m2: mem) : Type0 | let mm_refs_pred (m1 m2:mem) :Type0
= forall (a:Type) (rel:preorder a) (r:HS.mreference a rel).{:pattern (m1 `HS.contains` r)}
(not (is_mm r)) \/
(m1 `HS.contains` r ==>
(m2 `HS.contains` r /\ rel (HS.sel m1 r) (HS.sel m2 r) \/
r `HS.unused_in` m2)) | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 29,
"end_line": 82,
"start_col": 8,
"start_line": 77
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | m1: FStar.Monotonic.HyperStack.mem -> m2: FStar.Monotonic.HyperStack.mem -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"Prims.l_Forall",
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperStack.mreference",
"Prims.l_or",
"Prims.b2t",
"Prims.op_Negation",
"FStar.Monotonic.HyperStack.is_mm",
"Prims.l_imp",
"FStar.Monotonic.HyperStack.contains",
"Prims.l_and",
"FStar.Monotonic.Hype... | [] | false | false | false | true | true | let mm_refs_pred (m1 m2: mem) : Type0 =
| forall (a: Type) (rel: preorder a) (r: HS.mreference a rel). {:pattern (m1 `HS.contains` r)}
(not (is_mm r)) \/
(m1 `HS.contains` r ==>
(m2 `HS.contains` r /\ rel (HS.sel m1 r) (HS.sel m2 r) \/ r `HS.unused_in` m2)) | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.ref_contains_pred | val ref_contains_pred (#a:Type) (#rel:preorder a) (r:HS.mreference a rel) :mem_predicate | val ref_contains_pred (#a:Type) (#rel:preorder a) (r:HS.mreference a rel) :mem_predicate | let ref_contains_pred #_ #_ r =
fun m ->
let rid = HS.frameOf r in
rid_last_component rid < get_rid_ctr m /\
(m `contains_region` rid ==> (
(HS.as_addr r < Heap.next_addr (Map.sel (HS.get_hmap m) rid)) /\
(HS.is_mm r ==> (m `HS.contains` r \/ r `HS.unused_in` m)) /\
((not (HS.is_mm r)) ==> m `HS.contai... | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 47,
"end_line": 102,
"start_col": 0,
"start_line": 95
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r: FStar.Monotonic.HyperStack.mreference a rel -> FStar.HyperStack.ST.mem_predicate | Prims.Tot | [
"total"
] | [] | [
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperStack.mreference",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Monotonic.HyperHeap.rid_last_component",
"FStar.Monotonic.HyperStack.get_rid_ctr",
"Prims.l_imp",
"FStar.HyperStack.ST.contains_region",
"... | [] | false | false | false | false | false | let ref_contains_pred #_ #_ r =
| fun m ->
let rid = HS.frameOf r in
rid_last_component rid < get_rid_ctr m /\
(m `contains_region` rid ==>
((HS.as_addr r < Heap.next_addr (Map.sel (HS.get_hmap m) rid)) /\
(HS.is_mm r ==> (m `HS.contains` r \/ r `HS.unused_in` m)) /\
((not (HS.is_mm r)) ==> m `HS.contains` r))) | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.region_contains_pred | val region_contains_pred (r:HS.rid) :mem_predicate | val region_contains_pred (r:HS.rid) :mem_predicate | let region_contains_pred r =
fun m -> (not (HS.is_eternal_region_hs r)) \/ m `contains_region` r | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 69,
"end_line": 93,
"start_col": 0,
"start_line": 92
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r: FStar.Monotonic.HyperHeap.rid -> FStar.HyperStack.ST.mem_predicate | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.HyperHeap.rid",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_or",
"Prims.b2t",
"Prims.op_Negation",
"FStar.Monotonic.HyperStack.is_eternal_region_hs",
"FStar.HyperStack.ST.contains_region"
] | [] | false | false | false | true | false | let region_contains_pred r =
| fun m -> (not (HS.is_eternal_region_hs r)) \/ m `contains_region` r | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.stable | val stable (p:mem_predicate) :Type0 | val stable (p:mem_predicate) :Type0 | let stable p = forall (h1:mem) (h2:mem).{:pattern (mem_rel h1 h2)} (p h1 /\ mem_rel h1 h2) ==> p h2 | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 99,
"end_line": 104,
"start_col": 0,
"start_line": 104
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p: FStar.HyperStack.ST.mem_predicate -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.HyperStack.ST.mem_predicate",
"Prims.l_Forall",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_imp",
"Prims.l_and",
"FStar.HyperStack.ST.mem_rel"
] | [] | false | false | false | true | true | let stable p =
| forall (h1: mem) (h2: mem). {:pattern (mem_rel h1 h2)} (p h1 /\ mem_rel h1 h2) ==> p h2 | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.witnessed | val witnessed (p:mem_predicate) :Type0 | val witnessed (p:mem_predicate) :Type0 | let witnessed p = W.witnessed mem_rel p | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 39,
"end_line": 106,
"start_col": 0,
"start_line": 106
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p: FStar.HyperStack.ST.mem_predicate -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.HyperStack.ST.mem_predicate",
"FStar.Monotonic.Witnessed.witnessed",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.mem_rel"
] | [] | false | false | false | true | true | let witnessed p =
| W.witnessed mem_rel p | false |
Pulse.Checker.Bind.fst | Pulse.Checker.Bind.check_tot_bind | val check_tot_bind
(g:env)
(pre:term)
(pre_typing:tot_typing g pre tm_vprop)
(post_hint:post_hint_opt g)
(res_ppname:ppname)
(t:st_term { Tm_TotBind? t.term })
(check:check_t)
: T.Tac (checker_result_t g pre post_hint) | val check_tot_bind
(g:env)
(pre:term)
(pre_typing:tot_typing g pre tm_vprop)
(post_hint:post_hint_opt g)
(res_ppname:ppname)
(t:st_term { Tm_TotBind? t.term })
(check:check_t)
: T.Tac (checker_result_t g pre post_hint) | let check_tot_bind
(g:env)
(pre:term)
(pre_typing:tot_typing g pre tm_vprop)
(post_hint:post_hint_opt g)
(res_ppname:ppname)
(t:st_term { Tm_TotBind? t.term })
(check:check_t)
: T.Tac (checker_result_t g pre post_hint) =
let g = Pulse.Typing.Env.push_context g "check_tot_bind" t.range in
if None? ... | {
"file_name": "lib/steel/pulse/Pulse.Checker.Bind.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 3,
"end_line": 158,
"start_col": 0,
"start_line": 130
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Pulse.Typing.Metatheory.fsti.checked",
"Pulse.Typing.Env.fsti.checked",
"Pulse.Typing.Combinators.fsti.checked",
"Pulse.Typing.fst.checked",
"Pulse.Syntax.Printer.fsti.checked",
"Pulse.Syntax.fst.checked",
"Pulse.Checker.Pure.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "Pulse.Checker.Abs",
"short_module": "Abs"
},
{
"abbrev": true,
"full_module": "Pulse.Checker.Prover.Substs",
"short_module": "PS"
},
{
"abbrev": true,
"full_module": "Pulse.Typing.Metatheory",
"short_module": "Metatheory"
},
{
"ab... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
g: Pulse.Typing.Env.env ->
pre: Pulse.Syntax.Base.term ->
pre_typing: Pulse.Typing.tot_typing g pre Pulse.Syntax.Base.tm_vprop ->
post_hint: Pulse.Typing.post_hint_opt g ->
res_ppname: Pulse.Syntax.Base.ppname ->
t: Pulse.Syntax.Base.st_term{Tm_TotBind? (Mkst_term?.term t)} ->
check: Pulse.... | FStar.Tactics.Effect.Tac | [] | [] | [
"Pulse.Typing.Env.env",
"Pulse.Syntax.Base.term",
"Pulse.Typing.tot_typing",
"Pulse.Syntax.Base.tm_vprop",
"Pulse.Typing.post_hint_opt",
"Pulse.Syntax.Base.ppname",
"Pulse.Syntax.Base.st_term",
"Prims.b2t",
"Pulse.Syntax.Base.uu___is_Tm_TotBind",
"Pulse.Syntax.Base.__proj__Mkst_term__item__term",
... | [] | false | true | false | false | false | let check_tot_bind
(g: env)
(pre: term)
(pre_typing: tot_typing g pre tm_vprop)
(post_hint: post_hint_opt g)
(res_ppname: ppname)
(t: st_term{Tm_TotBind? t.term})
(check: check_t)
: T.Tac (checker_result_t g pre post_hint) =
| let g = Pulse.Typing.Env.push_context g "check_tot_bind" t.range in
if None? post_hint
then fail g (Some t.range) "check_tot_bind: post hint is not set, please add an annotation";
let Tm_TotBind { binder = b ; head = e1 ; body = e2 } = t.term in
match Pulse.Checker.Base.is_stateful_application g e1 with
| Some st_app -... | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.mem_rel | val mem_rel :preorder mem | val mem_rel :preorder mem | let mem_rel :preorder mem
= HS.lemma_rid_ctr_pred (); HS.lemma_next_addr_contained_refs_addr ();
fun (m1 m2:mem) ->
eternal_region_pred m1 m2 /\ rid_ctr_pred m1 m2 /\ rid_last_component_pred m1 m2 /\ eternal_refs_pred m1 m2 /\
next_ref_addr_in_a_region_pred m1 m2 /\ unused_ref_next_addr_pred m1 m2 /\ mm... | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 97,
"end_line": 89,
"start_col": 0,
"start_line": 85
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | FStar.Preorder.preorder FStar.Monotonic.HyperStack.mem | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"FStar.HyperStack.ST.eternal_region_pred",
"FStar.HyperStack.ST.rid_ctr_pred",
"FStar.HyperStack.ST.rid_last_component_pred",
"FStar.HyperStack.ST.eternal_refs_pred",
"FStar.HyperStack.ST.next_ref_addr_in_a_region_pred",
"FStar.HyperStack.ST.unused_ref_... | [] | false | false | false | true | false | let mem_rel:preorder mem =
| HS.lemma_rid_ctr_pred ();
HS.lemma_next_addr_contained_refs_addr ();
fun (m1: mem) (m2: mem) ->
eternal_region_pred m1 m2 /\ rid_ctr_pred m1 m2 /\ rid_last_component_pred m1 m2 /\
eternal_refs_pred m1 m2 /\ next_ref_addr_in_a_region_pred m1 m2 /\ unused_ref_next_addr_pred m1 m2 /\
mm_refs_pred m1 m2 | false |
Steel.ST.Array.fst | Steel.ST.Array.ghost_join | val ghost_join
(#opened: _)
(#elt: Type)
(#x1 #x2: Seq.seq elt)
(#p: P.perm)
(a1 a2: array elt)
(h: squash (adjacent a1 a2))
: STGhostT unit opened
(pts_to a1 p x1 `star` pts_to a2 p x2)
(fun res -> pts_to (merge a1 a2) p (x1 `Seq.append` x2)) | val ghost_join
(#opened: _)
(#elt: Type)
(#x1 #x2: Seq.seq elt)
(#p: P.perm)
(a1 a2: array elt)
(h: squash (adjacent a1 a2))
: STGhostT unit opened
(pts_to a1 p x1 `star` pts_to a2 p x2)
(fun res -> pts_to (merge a1 a2) p (x1 `Seq.append` x2)) | let ghost_join
#_ #_ #x1 #x2 #p a1 a2 h
= rewrite
(pts_to a1 _ _)
(H.pts_to a1 p (seq_map raise x1));
rewrite
(pts_to a2 _ _)
(H.pts_to a2 p (seq_map raise x2));
H.ghost_join a1 a2 h;
assert (seq_map raise (x1 `Seq.append` x2) `Seq.equal` (seq_map raise x1 `Seq.append` seq_map raise x2));
rewr... | {
"file_name": "lib/steel/Steel.ST.Array.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 30,
"end_line": 202,
"start_col": 0,
"start_line": 187
} | (*
Copyright 2020, 2021, 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law ... | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Reference.fsti.checked",
"Steel.ST.Loops.fsti.checked",
"Steel.ST.HigherArray.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.SizeT.fsti.checked",
"FStar.Seq.fst.che... | [
{
"abbrev": true,
"full_module": "Steel.ST.HigherArray",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "US"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": true,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
a1: Steel.ST.Array.array elt ->
a2: Steel.ST.Array.array elt ->
h: Prims.squash (Steel.ST.Array.adjacent a1 a2)
-> Steel.ST.Effect.Ghost.STGhostT Prims.unit | Steel.ST.Effect.Ghost.STGhostT | [] | [] | [
"Steel.Memory.inames",
"FStar.Seq.Base.seq",
"Steel.FractionalPermission.perm",
"Steel.ST.Array.array",
"Prims.squash",
"Steel.ST.Array.adjacent",
"Steel.ST.Util.rewrite",
"Steel.ST.HigherArray.pts_to",
"Steel.ST.Array.raise_t",
"Steel.ST.Array.merge",
"FStar.Ghost.hide",
"Steel.ST.Array.seq_m... | [] | false | true | false | false | false | let ghost_join #_ #_ #x1 #x2 #p a1 a2 h =
| rewrite (pts_to a1 _ _) (H.pts_to a1 p (seq_map raise x1));
rewrite (pts_to a2 _ _) (H.pts_to a2 p (seq_map raise x2));
H.ghost_join a1 a2 h;
assert ((seq_map raise (x1 `Seq.append` x2))
`Seq.equal`
((seq_map raise x1) `Seq.append` (seq_map raise x2)));
rewrite (H.pts_to _ _ _) (H.pts_to (merge a1 a2) p (seq_ma... | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.same_refs_in_all_regions | val same_refs_in_all_regions (m0 m1:mem) :Type0 | val same_refs_in_all_regions (m0 m1:mem) :Type0 | let same_refs_in_all_regions m0 m1 = same_refs_common contained_region m0 m1 | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 76,
"end_line": 117,
"start_col": 0,
"start_line": 117
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | m0: FStar.Monotonic.HyperStack.mem -> m1: FStar.Monotonic.HyperStack.mem -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.same_refs_common",
"FStar.HyperStack.ST.contained_region"
] | [] | false | false | false | true | true | let same_refs_in_all_regions m0 m1 =
| same_refs_common contained_region m0 m1 | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.same_refs_in_stack_regions | val same_refs_in_stack_regions (m0 m1:mem) :Type0 | val same_refs_in_stack_regions (m0 m1:mem) :Type0 | let same_refs_in_stack_regions m0 m1 = same_refs_common contained_stack_region m0 m1 | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 84,
"end_line": 118,
"start_col": 0,
"start_line": 118
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | m0: FStar.Monotonic.HyperStack.mem -> m1: FStar.Monotonic.HyperStack.mem -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.same_refs_common",
"FStar.HyperStack.ST.contained_stack_region"
] | [] | false | false | false | true | true | let same_refs_in_stack_regions m0 m1 =
| same_refs_common contained_stack_region m0 m1 | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.same_refs_in_non_tip_regions | val same_refs_in_non_tip_regions (m0 m1:mem) :Type0 | val same_refs_in_non_tip_regions (m0 m1:mem) :Type0 | let same_refs_in_non_tip_regions m0 m1 = same_refs_common contained_non_tip_region m0 m1 | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 88,
"end_line": 119,
"start_col": 0,
"start_line": 119
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | m0: FStar.Monotonic.HyperStack.mem -> m1: FStar.Monotonic.HyperStack.mem -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.same_refs_common",
"FStar.HyperStack.ST.contained_non_tip_region"
] | [] | false | false | false | true | true | let same_refs_in_non_tip_regions m0 m1 =
| same_refs_common contained_non_tip_region m0 m1 | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.same_refs_in_non_tip_stack_regions | val same_refs_in_non_tip_stack_regions (m0 m1:mem) :Type0 | val same_refs_in_non_tip_stack_regions (m0 m1:mem) :Type0 | let same_refs_in_non_tip_stack_regions m0 m1 = same_refs_common contained_non_tip_stack_region m0 m1 | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 100,
"end_line": 120,
"start_col": 0,
"start_line": 120
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | m0: FStar.Monotonic.HyperStack.mem -> m1: FStar.Monotonic.HyperStack.mem -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.same_refs_common",
"FStar.HyperStack.ST.contained_non_tip_stack_region"
] | [] | false | false | false | true | true | let same_refs_in_non_tip_stack_regions m0 m1 =
| same_refs_common contained_non_tip_stack_region m0 m1 | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.lemma_functoriality | val lemma_functoriality (p:mem_predicate{witnessed p}) (q:mem_predicate{(forall (h:mem). p h ==> q h)})
: Lemma (witnessed q) | val lemma_functoriality (p:mem_predicate{witnessed p}) (q:mem_predicate{(forall (h:mem). p h ==> q h)})
: Lemma (witnessed q) | let lemma_functoriality p q = W.lemma_witnessed_weakening mem_rel p q | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 69,
"end_line": 115,
"start_col": 0,
"start_line": 115
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
p: FStar.HyperStack.ST.mem_predicate{FStar.HyperStack.ST.witnessed p} ->
q: FStar.HyperStack.ST.mem_predicate{forall (h: FStar.Monotonic.HyperStack.mem). p h ==> q h}
-> FStar.Pervasives.Lemma (ensures FStar.HyperStack.ST.witnessed q) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.HyperStack.ST.mem_predicate",
"FStar.HyperStack.ST.witnessed",
"Prims.l_Forall",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_imp",
"FStar.Monotonic.Witnessed.lemma_witnessed_weakening",
"FStar.HyperStack.ST.mem_rel",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_functoriality p q =
| W.lemma_witnessed_weakening mem_rel p q | false |
Hacl.Impl.Box.fst | Hacl.Impl.Box.box_open_easy | val box_open_easy:
mlen:size_t{v mlen + 16 <= max_size_t}
-> m:lbuffer uint8 mlen
-> pk:lbuffer uint8 32ul
-> sk:lbuffer uint8 32ul
-> n:lbuffer uint8 24ul
-> c:lbuffer uint8 (mlen +! 16ul) ->
Stack size_t
(requires fun h ->
live h c /\ live h m /\ live h pk /\ live h sk /\ live h n /\
disjoin... | val box_open_easy:
mlen:size_t{v mlen + 16 <= max_size_t}
-> m:lbuffer uint8 mlen
-> pk:lbuffer uint8 32ul
-> sk:lbuffer uint8 32ul
-> n:lbuffer uint8 24ul
-> c:lbuffer uint8 (mlen +! 16ul) ->
Stack size_t
(requires fun h ->
live h c /\ live h m /\ live h pk /\ live h sk /\ live h n /\
disjoin... | let box_open_easy mlen m pk sk n c =
let tag = sub c 0ul 16ul in
let cip = sub c 16ul mlen in
box_open_detached mlen m pk sk n cip tag | {
"file_name": "code/nacl-box/Hacl.Impl.Box.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 42,
"end_line": 251,
"start_col": 0,
"start_line": 248
} | module Hacl.Impl.Box
open FStar.HyperStack.All
open FStar.HyperStack
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Hacl.Impl.SecretBox
module ST = FStar.HyperStack.ST
module Spec = Spec.Box
module LSeq = Lib.Sequence
#set-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
val box_bef... | {
"checked_file": "/",
"dependencies": [
"Spec.Box.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Salsa20.fst.checked",
"Hacl.Impl.SecretBox.fst.checked",
"Hacl.Curve2551... | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Spec.Box",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
mlen: Lib.IntTypes.size_t{Lib.IntTypes.v mlen + 16 <= Lib.IntTypes.max_size_t} ->
m: Lib.Buffer.lbuffer Lib.IntTypes.uint8 mlen ->
pk: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul ->
sk: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul ->
n: Lib.Buffer.lbuffer Lib.IntTypes.uint8 24ul ->
c: Lib.Buffer.l... | FStar.HyperStack.ST.Stack | [] | [] | [
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.IntTypes.max_size_t",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.op_Plus_Bang",
"Hacl.Impl.Box.box_op... | [] | false | true | false | false | false | let box_open_easy mlen m pk sk n c =
| let tag = sub c 0ul 16ul in
let cip = sub c 16ul mlen in
box_open_detached mlen m pk sk n cip tag | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.pop_frame | val pop_frame (_:unit)
:Unsafe unit (requires (fun m -> poppable m))
(ensures (fun (m0:mem) _ (m1:mem) -> poppable m0 /\ m1 == pop m0 /\ popped m0 m1)) | val pop_frame (_:unit)
:Unsafe unit (requires (fun m -> poppable m))
(ensures (fun (m0:mem) _ (m1:mem) -> poppable m0 /\ m1 == pop m0 /\ popped m0 m1)) | let pop_frame _ =
let m1 = pop (gst_get ()) in
gst_put m1 | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 12,
"end_line": 139,
"start_col": 0,
"start_line": 137
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | _: Prims.unit -> FStar.HyperStack.ST.Unsafe Prims.unit | FStar.HyperStack.ST.Unsafe | [] | [] | [
"Prims.unit",
"FStar.HyperStack.ST.gst_put",
"FStar.Monotonic.HyperStack.mem",
"FStar.Monotonic.HyperStack.pop",
"FStar.Monotonic.HyperStack.poppable",
"FStar.HyperStack.ST.gst_get"
] | [] | false | true | false | false | false | let pop_frame _ =
| let m1 = pop (gst_get ()) in
gst_put m1 | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.push_frame | val push_frame (_:unit) :Unsafe unit (requires (fun m -> True)) (ensures (fun (m0:mem) _ (m1:mem) -> fresh_frame m0 m1)) | val push_frame (_:unit) :Unsafe unit (requires (fun m -> True)) (ensures (fun (m0:mem) _ (m1:mem) -> fresh_frame m0 m1)) | let push_frame _ =
let m0 = gst_get () in
let m1 = HS.hs_push_frame m0 in
gst_put m1 | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 12,
"end_line": 135,
"start_col": 0,
"start_line": 132
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | _: Prims.unit -> FStar.HyperStack.ST.Unsafe Prims.unit | FStar.HyperStack.ST.Unsafe | [] | [] | [
"Prims.unit",
"FStar.HyperStack.ST.gst_put",
"FStar.Monotonic.HyperStack.mem",
"FStar.Monotonic.HyperStack.fresh_frame",
"FStar.Monotonic.HyperStack.hs_push_frame",
"FStar.HyperStack.ST.gst_get"
] | [] | false | true | false | false | false | let push_frame _ =
| let m0 = gst_get () in
let m1 = HS.hs_push_frame m0 in
gst_put m1 | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.sfree | val sfree (#a:Type) (#rel:preorder a) (r:mmmstackref a rel)
:StackInline unit (requires (fun m0 -> frameOf r = get_tip m0 /\ m0 `contains` r))
(ensures (fun m0 _ m1 -> m0 `contains` r /\ m1 == HS.free r m0)) | val sfree (#a:Type) (#rel:preorder a) (r:mmmstackref a rel)
:StackInline unit (requires (fun m0 -> frameOf r = get_tip m0 /\ m0 `contains` r))
(ensures (fun m0 _ m1 -> m0 `contains` r /\ m1 == HS.free r m0)) | let sfree #_ #_ r =
let m0 = gst_get () in
let m1 = HS.free r m0 in
assert (Set.equal (Map.domain (get_hmap m0)) (Map.domain (get_hmap m1)));
Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
Heap.lemma_next_addr_free_mm (Map.sel (HS.get_hmap m0) (HS.get_tip m0)) (HS... | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 12,
"end_line": 165,
"start_col": 0,
"start_line": 158
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r: FStar.HyperStack.ST.mmmstackref a rel -> FStar.HyperStack.ST.StackInline Prims.unit | FStar.HyperStack.ST.StackInline | [] | [] | [
"FStar.Preorder.preorder",
"FStar.HyperStack.ST.mmmstackref",
"FStar.HyperStack.ST.gst_put",
"Prims.unit",
"FStar.Monotonic.Heap.lemma_next_addr_free_mm",
"FStar.Map.sel",
"FStar.Monotonic.HyperHeap.rid",
"FStar.Monotonic.Heap.heap",
"FStar.Monotonic.HyperStack.get_hmap",
"FStar.Monotonic.HyperSta... | [] | false | true | false | false | false | let sfree #_ #_ r =
| let m0 = gst_get () in
let m1 = HS.free r m0 in
assert (Set.equal (Map.domain (get_hmap m0)) (Map.domain (get_hmap m1)));
Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
Heap.lemma_next_addr_free_mm (Map.sel (HS.get_hmap m0) (HS.get_tip m0)) (HS.as_ref r);
gst_put m1 | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.salloc_common | val salloc_common (#a: Type) (#rel: preorder a) (init: a) (mm: bool)
: StackInline (mreference a rel)
(requires (fun m -> is_stack_region (get_tip m)))
(ensures
(fun m0 s m1 -> is_stack_region (HS.frameOf s) /\ salloc_post init m0 s m1 /\ is_mm s == mm)
) | val salloc_common (#a: Type) (#rel: preorder a) (init: a) (mm: bool)
: StackInline (mreference a rel)
(requires (fun m -> is_stack_region (get_tip m)))
(ensures
(fun m0 s m1 -> is_stack_region (HS.frameOf s) /\ salloc_post init m0 s m1 /\ is_mm s == mm)
) | let salloc_common (#a:Type) (#rel:preorder a) (init:a) (mm:bool)
:StackInline (mreference a rel)
(requires (fun m -> is_stack_region (get_tip m)))
(ensures (fun m0 s m1 -> is_stack_region (HS.frameOf s) /\ salloc_post init m0 s m1 /\ is_mm s == mm))
= let m0 = gst_get () in
let r, m1 = HS.alloc rel (... | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 153,
"start_col": 8,
"start_line": 141
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | init: a -> mm: Prims.bool -> FStar.HyperStack.ST.StackInline (FStar.HyperStack.ST.mreference a rel) | FStar.HyperStack.ST.StackInline | [] | [] | [
"FStar.Preorder.preorder",
"Prims.bool",
"FStar.Monotonic.HyperStack.mreference",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.mreference",
"Prims.unit",
"FStar.HyperStack.ST.gst_witness",
"FStar.HyperStack.ST.region_contains_pred",
"FStar.Monotonic.HyperStack.frameOf",
"FStar.HyperStack... | [] | false | true | false | false | false | let salloc_common (#a: Type) (#rel: preorder a) (init: a) (mm: bool)
: StackInline (mreference a rel)
(requires (fun m -> is_stack_region (get_tip m)))
(ensures
(fun m0 s m1 -> is_stack_region (HS.frameOf s) /\ salloc_post init m0 s m1 /\ is_mm s == mm)
) =
| let m0 = gst_get () in
let r, m1 = HS.alloc rel (get_tip m0) init mm m0 in
Heap.lemma_next_addr_alloc rel (Map.sel (get_hmap m0) (get_tip m0)) init mm;
gst_put m1;
assert (Set.equal (Map.domain (get_hmap m0)) (Map.domain (get_hmap m1)));
HS.lemma_rid_ctr_pred ();
gst_witness (ref_contains_pred r);
gst_witness (region_c... | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.salloc | val salloc (#a:Type) (#rel:preorder a) (init:a)
:StackInline (mstackref a rel) (requires (fun m -> is_stack_region (get_tip m)))
(ensures salloc_post init) | val salloc (#a:Type) (#rel:preorder a) (init:a)
:StackInline (mstackref a rel) (requires (fun m -> is_stack_region (get_tip m)))
(ensures salloc_post init) | let salloc #_ #_ init = salloc_common init false | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 48,
"end_line": 155,
"start_col": 0,
"start_line": 155
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | init: a -> FStar.HyperStack.ST.StackInline (FStar.HyperStack.ST.mstackref a rel) | FStar.HyperStack.ST.StackInline | [] | [] | [
"FStar.Preorder.preorder",
"FStar.HyperStack.ST.salloc_common",
"FStar.HyperStack.ST.mreference",
"FStar.HyperStack.ST.mstackref"
] | [] | false | true | false | false | false | let salloc #_ #_ init =
| salloc_common init false | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.salloc_mm | val salloc_mm (#a:Type) (#rel:preorder a) (init:a)
:StackInline (mmmstackref a rel) (requires (fun m -> is_stack_region (get_tip m)))
(ensures salloc_post init) | val salloc_mm (#a:Type) (#rel:preorder a) (init:a)
:StackInline (mmmstackref a rel) (requires (fun m -> is_stack_region (get_tip m)))
(ensures salloc_post init) | let salloc_mm #_ #_ init = salloc_common init true | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 50,
"end_line": 156,
"start_col": 0,
"start_line": 156
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | init: a -> FStar.HyperStack.ST.StackInline (FStar.HyperStack.ST.mmmstackref a rel) | FStar.HyperStack.ST.StackInline | [] | [] | [
"FStar.Preorder.preorder",
"FStar.HyperStack.ST.salloc_common",
"FStar.HyperStack.ST.mreference",
"FStar.HyperStack.ST.mmmstackref"
] | [] | false | true | false | false | false | let salloc_mm #_ #_ init =
| salloc_common init true | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.mem_rel_predicate | val mem_rel_predicate (#a: Type0) (#rel: preorder a) (r: mreference a rel) (p: mem_predicate)
: mem_predicate | val mem_rel_predicate (#a: Type0) (#rel: preorder a) (r: mreference a rel) (p: mem_predicate)
: mem_predicate | let mem_rel_predicate (#a:Type0) (#rel:preorder a) (r:mreference a rel) (p:mem_predicate)
:mem_predicate
= let rid = HS.frameOf r in
fun m ->
(HS.rid_last_component rid < HS.get_rid_ctr m) /\ ( //will help us prove that a deallocated region remains deallocated
(m `HS.contains` r /\ p m) \/ //the ref... | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 285,
"start_col": 8,
"start_line": 278
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r: FStar.HyperStack.ST.mreference a rel -> p: FStar.HyperStack.ST.mem_predicate
-> FStar.HyperStack.ST.mem_predicate | Prims.Tot | [
"total"
] | [] | [
"FStar.Preorder.preorder",
"FStar.HyperStack.ST.mreference",
"FStar.HyperStack.ST.mem_predicate",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Monotonic.HyperHeap.rid_last_component",
"FStar.Monotonic.HyperStack.get_rid_ctr",
"Prims.l_or",
"FStar.Mono... | [] | false | false | false | false | false | let mem_rel_predicate (#a: Type0) (#rel: preorder a) (r: mreference a rel) (p: mem_predicate)
: mem_predicate =
| let rid = HS.frameOf r in
fun m ->
(HS.rid_last_component rid < HS.get_rid_ctr m) /\
((m `HS.contains` r /\ p m) \/
(m `contains_region` rid /\ ~(m `HS.contains_ref_in_its_region` r) /\
HS.as_addr r < Heap.next_addr ((HS.get_hmap m) `Map.sel` rid) /\ r `HS.unused_in` m) \/
(not (m `contains_region` ri... | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.token_p | val token_p (#a:Type0) (#rel:preorder a) (r:mreference a rel) (p:mem_predicate) :Type0 | val token_p (#a:Type0) (#rel:preorder a) (r:mreference a rel) (p:mem_predicate) :Type0 | let token_p #_ #_ r p = witnessed (mem_rel_predicate r p) | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 57,
"end_line": 287,
"start_col": 0,
"start_line": 287
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r: FStar.HyperStack.ST.mreference a rel -> p: FStar.HyperStack.ST.mem_predicate -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Preorder.preorder",
"FStar.HyperStack.ST.mreference",
"FStar.HyperStack.ST.mem_predicate",
"FStar.HyperStack.ST.witnessed",
"FStar.HyperStack.ST.mem_rel_predicate"
] | [] | false | false | false | false | true | let token_p #_ #_ r p =
| witnessed (mem_rel_predicate r p) | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.ralloc_common | val ralloc_common (#a: Type) (#rel: preorder a) (i: rid) (init: a) (mm: bool)
: ST (mreference a rel)
(requires (fun m -> is_heap_color (color i) /\ m `contains_region` i))
(ensures (fun m0 r m1 -> ralloc_post i init m0 r m1 /\ is_mm r == mm)) | val ralloc_common (#a: Type) (#rel: preorder a) (i: rid) (init: a) (mm: bool)
: ST (mreference a rel)
(requires (fun m -> is_heap_color (color i) /\ m `contains_region` i))
(ensures (fun m0 r m1 -> ralloc_post i init m0 r m1 /\ is_mm r == mm)) | let ralloc_common (#a:Type) (#rel:preorder a) (i:rid) (init:a) (mm:bool)
:ST (mreference a rel)
(requires (fun m -> is_heap_color (color i) /\ m `contains_region` i))
(ensures (fun m0 r m1 -> ralloc_post i init m0 r m1 /\ is_mm r == mm))
= let m0 = gst_get () in
let r, m1 = HS.alloc rel i ini... | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 197,
"start_col": 8,
"start_line": 185
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | i: FStar.Monotonic.HyperHeap.rid -> init: a -> mm: Prims.bool
-> FStar.HyperStack.ST.ST (FStar.HyperStack.ST.mreference a rel) | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperHeap.rid",
"Prims.bool",
"FStar.Monotonic.HyperStack.mreference",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.mreference",
"Prims.unit",
"FStar.HyperStack.ST.gst_witness",
"FStar.HyperStack.ST.region_contains_pred",
"FStar.HyperStack.ST.r... | [] | false | true | false | false | false | let ralloc_common (#a: Type) (#rel: preorder a) (i: rid) (init: a) (mm: bool)
: ST (mreference a rel)
(requires (fun m -> is_heap_color (color i) /\ m `contains_region` i))
(ensures (fun m0 r m1 -> ralloc_post i init m0 r m1 /\ is_mm r == mm)) =
| let m0 = gst_get () in
let r, m1 = HS.alloc rel i init mm m0 in
Heap.lemma_next_addr_alloc rel (Map.sel (HS.get_hmap m0) i) init mm;
gst_put m1;
assert (Set.equal (Map.domain (get_hmap m0)) (Map.domain (get_hmap m1)));
HS.lemma_rid_ctr_pred ();
gst_witness (ref_contains_pred r);
gst_witness (region_contains_pred i);
r | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.ralloc | val ralloc (#a:Type) (#rel:preorder a) (i:rid) (init:a)
:ST (mref a rel) (requires (fun m -> is_eternal_region i))
(ensures (ralloc_post i init)) | val ralloc (#a:Type) (#rel:preorder a) (i:rid) (init:a)
:ST (mref a rel) (requires (fun m -> is_eternal_region i))
(ensures (ralloc_post i init)) | let ralloc #_ #_ i init =
if i <> HS.root then gst_recall (region_contains_pred i);
ralloc_common i init false | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 201,
"start_col": 0,
"start_line": 199
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | i: FStar.Monotonic.HyperHeap.rid -> init: a
-> FStar.HyperStack.ST.ST (FStar.HyperStack.ST.mref a rel) | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperHeap.rid",
"FStar.HyperStack.ST.ralloc_common",
"FStar.HyperStack.ST.mreference",
"Prims.unit",
"Prims.op_disEquality",
"FStar.Monotonic.HyperHeap.root",
"FStar.HyperStack.ST.gst_recall",
"FStar.HyperStack.ST.region_contains_pred",
"Prims.bool",
"... | [] | false | true | false | false | false | let ralloc #_ #_ i init =
| if i <> HS.root then gst_recall (region_contains_pred i);
ralloc_common i init false | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.recall_region | val recall_region (i:rid{is_eternal_region i})
:Stack unit (requires (fun m -> True))
(ensures (fun m0 _ m1 -> m0 == m1 /\ i `is_in` get_hmap m1)) | val recall_region (i:rid{is_eternal_region i})
:Stack unit (requires (fun m -> True))
(ensures (fun m0 _ m1 -> m0 == m1 /\ i `is_in` get_hmap m1)) | let recall_region i = if i <> HS.root then gst_recall (region_contains_pred i) | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 78,
"end_line": 243,
"start_col": 0,
"start_line": 243
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | i: FStar.Monotonic.HyperHeap.rid{FStar.HyperStack.ST.is_eternal_region i}
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"FStar.Monotonic.HyperHeap.rid",
"FStar.HyperStack.ST.is_eternal_region",
"Prims.op_disEquality",
"Prims.l_or",
"Prims.l_and",
"Prims.eq2",
"Prims.int",
"FStar.Monotonic.HyperHeap.color",
"Prims.b2t",
"Prims.op_Negation",
"FStar.Monotonic.HyperHeap.rid_freeable",
"FStar.Monotonic.HyperHeap.roo... | [] | false | true | false | false | false | let recall_region i =
| if i <> HS.root then gst_recall (region_contains_pred i) | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.op_Bang | val op_Bang (#a:Type) (#rel:preorder a) (r:mreference a rel)
:Stack a (requires (fun m -> r `is_live_for_rw_in` m))
(ensures (deref_post r)) | val op_Bang (#a:Type) (#rel:preorder a) (r:mreference a rel)
:Stack a (requires (fun m -> r `is_live_for_rw_in` m))
(ensures (deref_post r)) | let op_Bang #_ #_ r =
let m0 = gst_get () in
gst_recall (region_contains_pred (HS.frameOf r));
gst_recall (ref_contains_pred r);
Heap.lemma_sel_equals_sel_tot_for_contained_refs (get_hmap m0 `Map.sel` (HS.frameOf r)) (HS.as_ref r);
HS.sel_tot m0 r | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 17,
"end_line": 235,
"start_col": 0,
"start_line": 230
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r: FStar.HyperStack.ST.mreference a rel -> FStar.HyperStack.ST.Stack a | FStar.HyperStack.ST.Stack | [] | [] | [
"FStar.Preorder.preorder",
"FStar.HyperStack.ST.mreference",
"FStar.Monotonic.HyperStack.sel_tot",
"Prims.unit",
"FStar.Monotonic.Heap.lemma_sel_equals_sel_tot_for_contained_refs",
"FStar.Map.sel",
"FStar.Monotonic.HyperHeap.rid",
"FStar.Monotonic.Heap.heap",
"FStar.Monotonic.HyperStack.get_hmap",
... | [] | false | true | false | false | false | let ( ! ) #_ #_ r =
| let m0 = gst_get () in
gst_recall (region_contains_pred (HS.frameOf r));
gst_recall (ref_contains_pred r);
Heap.lemma_sel_equals_sel_tot_for_contained_refs ((get_hmap m0) `Map.sel` (HS.frameOf r))
(HS.as_ref r);
HS.sel_tot m0 r | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.mr_witness | val mr_witness (#r:erid) (#a:Type) (#b:preorder a)
(m:m_rref r a b) (p:mem_predicate)
:ST unit (requires (fun h0 -> p h0 /\ stable_on_t m p))
(ensures (fun h0 _ h1 -> h0==h1 /\ witnessed p)) | val mr_witness (#r:erid) (#a:Type) (#b:preorder a)
(m:m_rref r a b) (p:mem_predicate)
:ST unit (requires (fun h0 -> p h0 /\ stable_on_t m p))
(ensures (fun h0 _ h1 -> h0==h1 /\ witnessed p)) | let mr_witness #r #_ #_ m p =
recall m;
let p_pred (#i:erid) (#a:Type) (#b:preorder a)
(r:m_rref i a b) (p:mem_predicate)
:mem_predicate
= fun m -> m `contains` r /\ p m
in
gst_witness (p_pred m p);
lemma_functoriality (p_pred m p) p | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 259,
"start_col": 0,
"start_line": 251
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | m: FStar.HyperStack.ST.m_rref r a b -> p: FStar.HyperStack.ST.mem_predicate
-> FStar.HyperStack.ST.ST Prims.unit | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.HyperStack.ST.erid",
"FStar.Preorder.preorder",
"FStar.HyperStack.ST.m_rref",
"FStar.HyperStack.ST.mem_predicate",
"FStar.HyperStack.ST.lemma_functoriality",
"Prims.unit",
"FStar.HyperStack.ST.gst_witness",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"FStar.Monotonic.HyperStack.contain... | [] | false | true | false | false | false | let mr_witness #r #_ #_ m p =
| recall m;
let p_pred (#i: erid) (#a: Type) (#b: preorder a) (r: m_rref i a b) (p: mem_predicate)
: mem_predicate =
fun m -> m `contains` r /\ p m
in
gst_witness (p_pred m p);
lemma_functoriality (p_pred m p) p | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.ralloc_mm | val ralloc_mm (#a:Type) (#rel:preorder a) (i:rid) (init:a)
:ST (mmmref a rel) (requires (fun m -> is_eternal_region i))
(ensures (ralloc_post i init)) | val ralloc_mm (#a:Type) (#rel:preorder a) (i:rid) (init:a)
:ST (mmmref a rel) (requires (fun m -> is_eternal_region i))
(ensures (ralloc_post i init)) | let ralloc_mm #_ #_ i init =
if i <> HS.root then gst_recall (region_contains_pred i);
ralloc_common i init true | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 27,
"end_line": 205,
"start_col": 0,
"start_line": 203
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | i: FStar.Monotonic.HyperHeap.rid -> init: a
-> FStar.HyperStack.ST.ST (FStar.HyperStack.ST.mmmref a rel) | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperHeap.rid",
"FStar.HyperStack.ST.ralloc_common",
"FStar.HyperStack.ST.mreference",
"Prims.unit",
"Prims.op_disEquality",
"FStar.Monotonic.HyperHeap.root",
"FStar.HyperStack.ST.gst_recall",
"FStar.HyperStack.ST.region_contains_pred",
"Prims.bool",
"... | [] | false | true | false | false | false | let ralloc_mm #_ #_ i init =
| if i <> HS.root then gst_recall (region_contains_pred i);
ralloc_common i init true | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.rfree | val rfree (#a:Type) (#rel:preorder a) (r:mreference a rel{HS.is_mm r /\ HS.is_heap_color (HS.color (HS.frameOf r))})
:ST unit (requires (fun m0 -> r `is_live_for_rw_in` m0))
(ensures (fun m0 _ m1 -> m0 `contains` r /\ m1 == HS.free r m0)) | val rfree (#a:Type) (#rel:preorder a) (r:mreference a rel{HS.is_mm r /\ HS.is_heap_color (HS.color (HS.frameOf r))})
:ST unit (requires (fun m0 -> r `is_live_for_rw_in` m0))
(ensures (fun m0 _ m1 -> m0 `contains` r /\ m1 == HS.free r m0)) | let rfree #_ #_ r =
let m0 = gst_get () in
gst_recall (region_contains_pred (HS.frameOf r));
gst_recall (ref_contains_pred r);
HS.lemma_rid_ctr_pred ();
let m1 = HS.free r m0 in
assert (Set.equal (Map.domain (get_hmap m0)) (Map.domain (get_hmap m1)));
Heap.lemma_distinct_addrs_distinct_preorders ();
Hea... | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 12,
"end_line": 217,
"start_col": 0,
"start_line": 207
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
r:
FStar.HyperStack.ST.mreference a rel
{ FStar.Monotonic.HyperStack.is_mm r /\
FStar.Monotonic.HyperStack.is_heap_color (FStar.Monotonic.HyperHeap.color (FStar.Monotonic.HyperStack.frameOf
r)) }
-> FStar.HyperStack.ST.ST Prims.unit | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Preorder.preorder",
"FStar.HyperStack.ST.mreference",
"Prims.l_and",
"Prims.b2t",
"FStar.Monotonic.HyperStack.is_mm",
"FStar.Monotonic.HyperStack.is_heap_color",
"FStar.Monotonic.HyperHeap.color",
"FStar.Monotonic.HyperStack.frameOf",
"FStar.HyperStack.ST.gst_put",
"Prims.unit",
"FStar.Mo... | [] | false | true | false | false | false | let rfree #_ #_ r =
| let m0 = gst_get () in
gst_recall (region_contains_pred (HS.frameOf r));
gst_recall (ref_contains_pred r);
HS.lemma_rid_ctr_pred ();
let m1 = HS.free r m0 in
assert (Set.equal (Map.domain (get_hmap m0)) (Map.domain (get_hmap m1)));
Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm (... | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.testify | val testify (p:mem_predicate)
:ST unit (requires (fun _ -> witnessed p))
(ensures (fun h0 _ h1 -> h0==h1 /\ p h1)) | val testify (p:mem_predicate)
:ST unit (requires (fun _ -> witnessed p))
(ensures (fun h0 _ h1 -> h0==h1 /\ p h1)) | let testify (p:mem_predicate) = gst_recall p | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 44,
"end_line": 267,
"start_col": 0,
"start_line": 267
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p: FStar.HyperStack.ST.mem_predicate -> FStar.HyperStack.ST.ST Prims.unit | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.HyperStack.ST.mem_predicate",
"FStar.HyperStack.ST.gst_recall",
"Prims.unit"
] | [] | false | true | false | false | false | let testify (p: mem_predicate) =
| gst_recall p | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.new_region | val new_region (r0:rid)
:ST rid
(requires (fun m -> is_eternal_region r0))
(ensures (fun m0 r1 m1 ->
new_region_post_common r0 r1 m0 m1 /\
HS.color r1 = HS.color r0 /\
is_eternal_region r1 /\
(... | val new_region (r0:rid)
:ST rid
(requires (fun m -> is_eternal_region r0))
(ensures (fun m0 r1 m1 ->
new_region_post_common r0 r1 m0 m1 /\
HS.color r1 = HS.color r0 /\
is_eternal_region r1 /\
(... | let new_region r0 =
if r0 <> HS.root then gst_recall (region_contains_pred r0); //recall containment of r0
HS.lemma_rid_ctr_pred ();
let m0 = gst_get () in
let new_rid, m1 = HS.new_eternal_region m0 r0 None in
gst_put m1;
gst_witness (region_contains_pred new_rid);
new_rid | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 9,
"end_line": 174,
"start_col": 0,
"start_line": 167
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r0: FStar.Monotonic.HyperHeap.rid -> FStar.HyperStack.ST.ST FStar.Monotonic.HyperHeap.rid | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Monotonic.HyperHeap.rid",
"FStar.Monotonic.HyperStack.mem",
"Prims.unit",
"FStar.HyperStack.ST.gst_witness",
"FStar.HyperStack.ST.region_contains_pred",
"FStar.HyperStack.ST.gst_put",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.HyperStack.fresh_region",
"FStar.Pervasives.Native.fst",
... | [] | false | true | false | false | false | let new_region r0 =
| if r0 <> HS.root then gst_recall (region_contains_pred r0);
HS.lemma_rid_ctr_pred ();
let m0 = gst_get () in
let new_rid, m1 = HS.new_eternal_region m0 r0 None in
gst_put m1;
gst_witness (region_contains_pred new_rid);
new_rid | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.witness_region | val witness_region (i:rid)
:Stack unit (requires (fun m0 -> HS.is_eternal_region_hs i ==> i `is_in` get_hmap m0))
(ensures (fun m0 _ m1 -> m0 == m1 /\ witnessed (region_contains_pred i))) | val witness_region (i:rid)
:Stack unit (requires (fun m0 -> HS.is_eternal_region_hs i ==> i `is_in` get_hmap m0))
(ensures (fun m0 _ m1 -> m0 == m1 /\ witnessed (region_contains_pred i))) | let witness_region i = gst_witness (region_contains_pred i) | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 59,
"end_line": 244,
"start_col": 0,
"start_line": 244
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | i: FStar.Monotonic.HyperHeap.rid -> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"FStar.Monotonic.HyperHeap.rid",
"FStar.HyperStack.ST.gst_witness",
"FStar.HyperStack.ST.region_contains_pred",
"Prims.unit"
] | [] | false | true | false | false | false | let witness_region i =
| gst_witness (region_contains_pred i) | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.rid_of_drgn | val rid_of_drgn (d:drgn) : d_hrid | val rid_of_drgn (d:drgn) : d_hrid | let rid_of_drgn d = d | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 21,
"end_line": 318,
"start_col": 0,
"start_line": 318
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | d: FStar.HyperStack.ST.drgn -> FStar.HyperStack.ST.d_hrid | Prims.Tot | [
"total"
] | [] | [
"FStar.HyperStack.ST.drgn",
"FStar.HyperStack.ST.d_hrid"
] | [] | false | false | false | true | false | let rid_of_drgn d =
| d | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.new_colored_region | val new_colored_region (r0:rid) (c:int)
:ST rid
(requires (fun m -> HS.is_heap_color c /\ is_eternal_region r0))
(ensures (fun m0 r1 m1 ->
new_region_post_common r0 r1 m0 m1 /\
HS.color r1 = c /\
is_eternal_region r1 ... | val new_colored_region (r0:rid) (c:int)
:ST rid
(requires (fun m -> HS.is_heap_color c /\ is_eternal_region r0))
(ensures (fun m0 r1 m1 ->
new_region_post_common r0 r1 m0 m1 /\
HS.color r1 = c /\
is_eternal_region r1 ... | let new_colored_region r0 c =
if r0 <> HS.root then gst_recall (region_contains_pred r0); //recall containment of r0
HS.lemma_rid_ctr_pred ();
let m0 = gst_get () in
let new_rid, m1 = HS.new_eternal_region m0 r0 (Some c) in
gst_put m1;
gst_witness (region_contains_pred new_rid);
new_rid | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 9,
"end_line": 183,
"start_col": 0,
"start_line": 176
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r0: FStar.Monotonic.HyperHeap.rid -> c: Prims.int
-> FStar.HyperStack.ST.ST FStar.Monotonic.HyperHeap.rid | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Monotonic.HyperHeap.rid",
"Prims.int",
"FStar.Monotonic.HyperStack.mem",
"Prims.unit",
"FStar.HyperStack.ST.gst_witness",
"FStar.HyperStack.ST.region_contains_pred",
"FStar.HyperStack.ST.gst_put",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.HyperStack.fresh_region",
"FStar.Pervasives... | [] | false | true | false | false | false | let new_colored_region r0 c =
| if r0 <> HS.root then gst_recall (region_contains_pred r0);
HS.lemma_rid_ctr_pred ();
let m0 = gst_get () in
let new_rid, m1 = HS.new_eternal_region m0 r0 (Some c) in
gst_put m1;
gst_witness (region_contains_pred new_rid);
new_rid | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.op_Colon_Equals | val op_Colon_Equals (#a:Type) (#rel:preorder a) (r:mreference a rel) (v:a)
:STL unit (requires (fun m -> r `is_live_for_rw_in` m /\ rel (HS.sel m r) v))
(ensures (assign_post r v)) | val op_Colon_Equals (#a:Type) (#rel:preorder a) (r:mreference a rel) (v:a)
:STL unit (requires (fun m -> r `is_live_for_rw_in` m /\ rel (HS.sel m r) v))
(ensures (assign_post r v)) | let op_Colon_Equals #_ #_ r v =
let m0 = gst_get () in
gst_recall (region_contains_pred (HS.frameOf r));
gst_recall (ref_contains_pred r);
let m1 = HS.upd_tot m0 r v in
Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
Heap.lemma_upd_equals_upd_tot_for_contained_re... | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 12,
"end_line": 228,
"start_col": 0,
"start_line": 219
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r: FStar.HyperStack.ST.mreference a rel -> v: a -> FStar.HyperStack.ST.STL Prims.unit | FStar.HyperStack.ST.STL | [] | [] | [
"FStar.Preorder.preorder",
"FStar.HyperStack.ST.mreference",
"FStar.HyperStack.ST.gst_put",
"Prims.unit",
"FStar.Monotonic.Heap.lemma_next_addr_upd",
"FStar.Map.sel",
"FStar.Monotonic.HyperHeap.rid",
"FStar.Monotonic.Heap.heap",
"FStar.Monotonic.HyperStack.get_hmap",
"FStar.Monotonic.HyperStack.fr... | [] | false | true | false | false | false | let ( := ) #_ #_ r v =
| let m0 = gst_get () in
gst_recall (region_contains_pred (HS.frameOf r));
gst_recall (ref_contains_pred r);
let m1 = HS.upd_tot m0 r v in
Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm ();
Heap.lemma_upd_equals_upd_tot_for_contained_refs ((get_hmap m0) `Map.sel` (HS.frameOf r))
... | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.drgn | val drgn : Type0 | val drgn : Type0 | let drgn = d_hrid | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 17,
"end_line": 317,
"start_col": 0,
"start_line": 317
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.HyperStack.ST.d_hrid"
] | [] | false | false | false | true | true | let drgn =
| d_hrid | false |
FStar.HyperStack.ST.fst | FStar.HyperStack.ST.witness_hsref | val witness_hsref (#a:Type) (#rel:preorder a) (r:HS.mreference a rel)
:ST unit (fun h0 -> h0 `HS.contains` r)
(fun h0 _ h1 -> h0 == h1 /\ witnessed (ref_contains_pred r)) | val witness_hsref (#a:Type) (#rel:preorder a) (r:HS.mreference a rel)
:ST unit (fun h0 -> h0 `HS.contains` r)
(fun h0 _ h1 -> h0 == h1 /\ witnessed (ref_contains_pred r)) | let witness_hsref #_ #_ r =
HS.lemma_rid_ctr_pred ();
HS.lemma_next_addr_contained_refs_addr ();
gst_witness (ref_contains_pred r) | {
"file_name": "ulib/FStar.HyperStack.ST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 35,
"end_line": 249,
"start_col": 0,
"start_line": 246
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Heap.fst.checked",
"FS... | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r: FStar.Monotonic.HyperStack.mreference a rel -> FStar.HyperStack.ST.ST Prims.unit | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperStack.mreference",
"FStar.HyperStack.ST.gst_witness",
"FStar.HyperStack.ST.ref_contains_pred",
"Prims.unit",
"FStar.Monotonic.HyperStack.lemma_next_addr_contained_refs_addr",
"FStar.Monotonic.HyperStack.lemma_rid_ctr_pred"
] | [] | false | true | false | false | false | let witness_hsref #_ #_ r =
| HS.lemma_rid_ctr_pred ();
HS.lemma_next_addr_contained_refs_addr ();
gst_witness (ref_contains_pred r) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.