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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
FStar.Matrix.fst | FStar.Matrix.foldm_snoc_distributivity_left | val foldm_snoc_distributivity_left (#c #eq: _) (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a (SP.foldm_snoc add s)) `eq.eq` (SP.foldm_snoc add (const_op_seq mul a s))
)
(decreases SB.length s) | val foldm_snoc_distributivity_left (#c #eq: _) (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a (SP.foldm_snoc add s)) `eq.eq` (SP.foldm_snoc add (const_op_seq mul a s))
)
(decreases SB.length s) | let rec foldm_snoc_distributivity_left #c #eq (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult a (SP.foldm_snoc add s) `eq.eq`
SP.foldm_snoc add (const_op_seq mul a s))
(decreases SB.length... | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 79,
"end_line": 553,
"start_col": 0,
"start_line": 539
} | (*
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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_modu... | {
"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 |
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
a: c ->
s: FStar.Seq.Base.seq c
-> FStar.Pervasives.Lemma
(requires
FStar.Matrix.is_fully_distributive mul add /\ FStar.Matrix.is_absorber (CM?.unit add) mul)
(ensures
EQ?.eq eq
... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Seq.Base.seq",
"Prims.op_GreaterThan",
"FStar.Seq.Base.length",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__transitivity",
"Prims.unit",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__congruence",
"FStar.Alg... | [
"recursion"
] | false | false | true | false | false | let rec foldm_snoc_distributivity_left
#c
#eq
(mul: CE.cm c eq)
(add: CE.cm c eq)
(a: c)
(s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a (SP.foldm_snoc add s)) `eq.eq` (SP.foldm_snoc add (const_op_seq mul a s))... | if SB.length s > 0
then
let ( + ), ( * ), ( = ) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a ... | false |
Demo.Deps.fst | Demo.Deps.buffer | val buffer : a: Type0 -> Type0 | let buffer = B.buffer | {
"file_name": "examples/demos/low-star/Demo.Deps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 21,
"end_line": 26,
"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",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.chec... | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"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 | a: Type0 -> Type0 | Prims.Tot | [
"total"
] | [] | [
"LowStar.Buffer.buffer"
] | [] | false | false | false | true | true | let buffer =
| B.buffer | false | |
FStar.Matrix.fst | FStar.Matrix.terminal_case_two_aux | val terminal_case_two_aux
(#c #eq: _)
(#p: pos)
(#n: _)
(cm: CE.cm c eq)
(generator: matrix_generator c p n)
(m: pos{m = 1})
: Lemma
(ensures
(SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m * n)))
`eq.eq`
(SP.foldm_snoc cm (SB.init m (fun (... | val terminal_case_two_aux
(#c #eq: _)
(#p: pos)
(#n: _)
(cm: CE.cm c eq)
(generator: matrix_generator c p n)
(m: pos{m = 1})
: Lemma
(ensures
(SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m * n)))
`eq.eq`
(SP.foldm_snoc cm (SB.init m (fun (... | let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
... | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 205,
"start_col": 0,
"start_line": 190
} | (*
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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_modu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 0,
"max_fuel": 1,
"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 |
cm: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
generator: FStar.Matrix.matrix_generator c p n ->
m: Prims.pos{m = 1}
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(FStar.Seq.Permutation.foldm_snoc cm
(FStar.Seq.Base.slice (FStar.Matrix.seq_of_matrix (FStar.Matrix.init generato... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.matrix_generator",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__symmetry",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.Seq.Base.init",
"FStar... | [] | false | false | true | false | false | let terminal_case_two_aux
#c
#eq
(#p: pos)
#n
(cm: CE.cm c eq)
(generator: matrix_generator c p n)
(m: pos{m = 1})
: Lemma
(ensures
(SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m * n)))
`eq.eq`
(SP.foldm_snoc cm (SB.init m (fun (i: u... | SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert ((SP.foldm_snoc cm
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
`eq.eq`
(SP.foldm_snoc cm (SB.init n (generator 0))));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq g... | false |
Demo.Deps.fst | Demo.Deps.uint32 | val uint32 : Prims.eqtype | let uint32 = U32.t | {
"file_name": "examples/demos/low-star/Demo.Deps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 18,
"end_line": 28,
"start_col": 0,
"start_line": 28
} | (*
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",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.chec... | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"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 | Prims.eqtype | Prims.Tot | [
"total"
] | [] | [
"FStar.UInt32.t"
] | [] | false | false | false | true | false | let uint32 =
| U32.t | false | |
FStar.Matrix.fst | FStar.Matrix.matrix_fold_equals_double_fold | val matrix_fold_equals_double_fold
(#c #eq: _)
(#p: pos)
(#n: _)
(cm: CE.cm c eq)
(generator: matrix_generator c p n)
(m: pos{m <= p})
: Lemma
(ensures
(SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m * n)))
`eq.eq`
(SP.foldm_snoc cm... | val matrix_fold_equals_double_fold
(#c #eq: _)
(#p: pos)
(#n: _)
(cm: CE.cm c eq)
(generator: matrix_generator c p n)
(m: pos{m <= p})
: Lemma
(ensures
(SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m * n)))
`eq.eq`
(SP.foldm_snoc cm... | let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: un... | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 92,
"end_line": 285,
"start_col": 0,
"start_line": 242
} | (*
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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_modu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"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 |
cm: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
generator: FStar.Matrix.matrix_generator c p n ->
m: Prims.pos{m <= p}
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(FStar.Seq.Permutation.foldm_snoc cm
(FStar.Seq.Base.slice (FStar.Matrix.seq_of_matrix (FStar.Matrix.init... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.matrix_generator",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
"FStar.Matrix.terminal_case_aux",
"Prims.bool",
"FStar.Matrix.terminal_case_two_aux",
"FStar.Seq... | [
"recursion"
] | false | false | true | false | false | let rec matrix_fold_equals_double_fold
#c
#eq
(#p: pos)
#n
(cm: CE.cm c eq)
(generator: matrix_generator c p n)
(m: pos{m <= p})
: Lemma
(ensures
(SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m * n)))
`eq.eq`
(SP.foldm_snoc cm... | if p = 1
then terminal_case_aux cm generator m
else
if m = 1
then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m * n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m - 1)) -> SP... | false |
FStar.Matrix.fst | FStar.Matrix.foldm_snoc_distributivity_right | val foldm_snoc_distributivity_right (#c #eq: _) (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult (SP.foldm_snoc add s) a) `eq.eq` (SP.foldm_snoc add (seq_op_const mul s a))
)
(decreases SB.length s) | val foldm_snoc_distributivity_right (#c #eq: _) (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult (SP.foldm_snoc add s) a) `eq.eq` (SP.foldm_snoc add (seq_op_const mul s a))
)
(decreases SB.length s) | let rec foldm_snoc_distributivity_right #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add (seq_op_const mul s a))
(decreases SB.lengt... | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 79,
"end_line": 569,
"start_col": 0,
"start_line": 555
} | (*
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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_modu... | {
"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 |
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
s: FStar.Seq.Base.seq c ->
a: c
-> FStar.Pervasives.Lemma
(requires
FStar.Matrix.is_fully_distributive mul add /\ FStar.Matrix.is_absorber (CM?.unit add) mul)
(ensures
EQ?.eq eq
... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Seq.Base.seq",
"Prims.op_GreaterThan",
"FStar.Seq.Base.length",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__transitivity",
"Prims.unit",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__congruence",
"FStar.Alg... | [
"recursion"
] | false | false | true | false | false | let rec foldm_snoc_distributivity_right
#c
#eq
(mul: CE.cm c eq)
(add: CE.cm c eq)
(s: SB.seq c)
(a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult (SP.foldm_snoc add s) a) `eq.eq` (SP.foldm_snoc add (seq_op_const mul s a)... | if SB.length s > 0
then
let ( + ), ( * ), ( = ) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (seq_op_const mul s a) in
foldm_snoc_distributivity_right mul add liat a;
SB.lemma_eq_elim rhs_liat (seq_op_const mul l... | false |
FStar.Matrix.fst | FStar.Matrix.matrix_mul_ijth_as_sum | val matrix_mul_ijth_as_sum (#c:_) (#eq:_) (#m #n #p:pos) (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) (i: under m) (k: under p)
: Lemma (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) | val matrix_mul_ijth_as_sum (#c:_) (#eq:_) (#m #n #p:pos) (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) (i: under m) (k: under p)
: Lemma (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) | let matrix_mul_ijth_as_sum #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
: Lemma (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) =
let r = SB.init n (fun (j: under n)... | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 51,
"end_line": 597,
"start_col": 0,
"start_line": 590
} | (*
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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"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 |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mx: FStar.Matrix.matrix c m n ->
my: FStar.Matrix.matrix c n p ->
i: FStar.IntegerIntervals.under m ->
k: FStar.IntegerIntervals.under p
-> FStar.Pervasives.Lemma
(ensures
FStar.Matrix.ijth... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.matrix",
"FStar.IntegerIntervals.under",
"FStar.Matrix.seq_of_products_lemma",
"FStar.Matrix.row",
"FStar.Matrix.col",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"FStar.Matrix.ijth",
"FSt... | [] | false | false | true | false | false | let matrix_mul_ijth_as_sum
#c
#eq
#m
#n
#p
(add: CE.cm c eq)
(mul: CE.cm c eq)
(mx: matrix c m n)
(my: matrix c n p)
i
k
: Lemma
(ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j... | let r = SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)) in
assert (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (seq_of_products mul (row mx i) (col my k)));
seq_of_products_lemma mul (row mx i) (col my k) r | false |
Demo.Deps.fst | Demo.Deps.uint8 | val uint8 : Prims.eqtype | let uint8 = U8.t | {
"file_name": "examples/demos/low-star/Demo.Deps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 16,
"end_line": 29,
"start_col": 0,
"start_line": 29
} | (*
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",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.chec... | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"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 | Prims.eqtype | Prims.Tot | [
"total"
] | [] | [
"FStar.UInt8.t"
] | [] | false | false | false | true | false | let uint8 =
| U8.t | false | |
Demo.Deps.fst | Demo.Deps.modifies | val modifies : b: LowStar.Buffer.buffer 'a ->
h0: FStar.Monotonic.HyperStack.mem ->
h1: FStar.Monotonic.HyperStack.mem
-> Type0 | let modifies (b:B.buffer 'a) h0 h1 = modifies (loc_buffer b) h0 h1 | {
"file_name": "examples/demos/low-star/Demo.Deps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 66,
"end_line": 36,
"start_col": 0,
"start_line": 36
} | (*
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",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.chec... | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"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 |
b: LowStar.Buffer.buffer 'a ->
h0: FStar.Monotonic.HyperStack.mem ->
h1: FStar.Monotonic.HyperStack.mem
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"LowStar.Buffer.buffer",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_buffer",
"LowStar.Buffer.trivial_preorder"
] | [] | false | false | false | true | true | let modifies (b: B.buffer 'a) h0 h1 =
| modifies (loc_buffer b) h0 h1 | false | |
FStar.Sequence.Base.fst | FStar.Sequence.Base.length | val length : #ty: Type -> seq ty -> nat | val length : #ty: Type -> seq ty -> nat | let length = FLT.length | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 23,
"end_line": 53,
"start_col": 0,
"start_line": 53
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 | _: FStar.Sequence.Base.seq ty -> Prims.nat | Prims.Tot | [
"total"
] | [] | [
"FStar.List.Tot.Base.length"
] | [] | false | false | false | true | false | let length =
| FLT.length | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.empty | val empty : #ty: Type -> seq ty | val empty : #ty: Type -> seq ty | let empty (#ty: Type) : seq ty = [] | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 35,
"end_line": 59,
"start_col": 0,
"start_line": 59
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 | FStar.Sequence.Base.seq ty | Prims.Tot | [
"total"
] | [] | [
"Prims.Nil",
"FStar.Sequence.Base.seq"
] | [] | false | false | false | true | false | let empty (#ty: Type) : seq ty =
| [] | false |
FStar.Matrix.fst | FStar.Matrix.double_foldm_snoc_of_equal_generators | val double_foldm_snoc_of_equal_generators
(#c #eq: _)
(#m #n: pos)
(cm: CE.cm c eq)
(f g: (under m -> under n -> c))
: Lemma (requires (forall (i: under m) (j: under n). (f i j) `eq.eq` (g i j)))
(ensures
(SP.foldm_snoc cm
(SB.init m
(fun (i: under m... | val double_foldm_snoc_of_equal_generators
(#c #eq: _)
(#m #n: pos)
(cm: CE.cm c eq)
(f g: (under m -> under n -> c))
: Lemma (requires (forall (i: under m) (j: under n). (f i j) `eq.eq` (g i j)))
(ensures
(SP.foldm_snoc cm
(SB.init m
(fun (i: under m... | let double_foldm_snoc_of_equal_generators #c #eq (#m #n: pos)
(cm: CE.cm c eq)
(f g: under m -> under n -> c)
: Lemma (requires (forall (i: under m) (j: under n). f i j `eq.eq` g i j))
(ensures SP.foldm_snoc cm (SB.init m ... | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 112,
"end_line": 660,
"start_col": 0,
"start_line": 649
} | (*
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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_modu... | {
"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 |
cm: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
f: (_: FStar.IntegerIntervals.under m -> _: FStar.IntegerIntervals.under n -> c) ->
g: (_: FStar.IntegerIntervals.under m -> _: FStar.IntegerIntervals.under n -> c)
-> FStar.Pervasives.Lemma
(requires
forall (i: FStar.IntegerIntervals.under m) (... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.IntegerIntervals.under",
"FStar.Seq.Permutation.foldm_snoc_of_equal_inits",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.Seq.Base.init",
"Prims.unit",
"FStar.Classical.forall_intro",
"FStar.Algebra.CommM... | [] | false | false | true | false | false | let double_foldm_snoc_of_equal_generators
#c
#eq
(#m: pos)
(#n: pos)
(cm: CE.cm c eq)
(f: (under m -> under n -> c))
(g: (under m -> under n -> c))
: Lemma (requires (forall (i: under m) (j: under n). (f i j) `eq.eq` (g i j)))
(ensures
(SP.foldm_snoc cm
... | let aux i
: Lemma
((SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))
`eq.eq`
(SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))) =
SP.foldm_snoc_of_equal_inits cm (fun j -> f i j) (fun j -> g i j)
in
Classical.forall_intro aux;
SP.foldm_snoc_of_equal_inits cm
(fun (i: under m) -... | false |
FStar.Matrix.fst | FStar.Matrix.seq_of_products_zeroes_lemma | val seq_of_products_zeroes_lemma
(#c #eq #m: _)
(mul: CE.cm c eq)
(z: c{is_absorber z mul})
(s: SB.seq c {SB.length s == m})
: Lemma (ensures (eq_of_seq eq (seq_of_products mul (SB.create m z) s) (SB.create m z))) | val seq_of_products_zeroes_lemma
(#c #eq #m: _)
(mul: CE.cm c eq)
(z: c{is_absorber z mul})
(s: SB.seq c {SB.length s == m})
: Lemma (ensures (eq_of_seq eq (seq_of_products mul (SB.create m z) s) (SB.create m z))) | let seq_of_products_zeroes_lemma #c #eq #m (mul: CE.cm c eq)
(z: c{is_absorber z mul})
(s: SB.seq c{SB.length s == m})
: Lemma (ensures (eq_of_seq eq (seq_of_products mul (SB.create m z) s) (SB.create m z)))
= eq_of_seq_from_element_equality eq (se... | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 94,
"end_line": 753,
"start_col": 0,
"start_line": 749
} | (*
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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_modu... | {
"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 |
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
z: c{FStar.Matrix.is_absorber z mul} ->
s: FStar.Seq.Base.seq c {FStar.Seq.Base.length s == m}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Equiv.eq_of_seq eq
(FStar.Matrix.seq_of_products mul (FStar.Seq.Base.create m z) s)
(FStar.S... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.nat",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.is_absorber",
"FStar.Seq.Base.seq",
"Prims.eq2",
"FStar.Seq.Base.length",
"FStar.Seq.Equiv.eq_of_seq_from_element_equality",
"FStar.Matrix.seq_of_products",
"FStar.Seq.Base.create",
"Prims.uni... | [] | true | false | true | false | false | let seq_of_products_zeroes_lemma
#c
#eq
#m
(mul: CE.cm c eq)
(z: c{is_absorber z mul})
(s: SB.seq c {SB.length s == m})
: Lemma (ensures (eq_of_seq eq (seq_of_products mul (SB.create m z) s) (SB.create m z))) =
| eq_of_seq_from_element_equality eq (seq_of_products mul (SB.create m z) s) (SB.create m z) | false |
Demo.Deps.fst | Demo.Deps.live | val live : h: FStar.Monotonic.HyperStack.mem -> b: Demo.Deps.buffer 'a -> Type0 | let live h (b:buffer 'a) = B.live h b | {
"file_name": "examples/demos/low-star/Demo.Deps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 37,
"end_line": 39,
"start_col": 0,
"start_line": 39
} | (*
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",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.chec... | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"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 | h: FStar.Monotonic.HyperStack.mem -> b: Demo.Deps.buffer 'a -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"Demo.Deps.buffer",
"LowStar.Monotonic.Buffer.live",
"LowStar.Buffer.trivial_preorder"
] | [] | false | false | false | true | true | let live h (b: buffer 'a) =
| B.live h b | false | |
FStar.Sequence.Base.fst | FStar.Sequence.Base.singleton | val singleton : #ty: Type -> ty -> seq ty | val singleton : #ty: Type -> ty -> seq ty | let singleton (#ty: Type) (v: ty) : seq ty =
[v] | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 66,
"start_col": 0,
"start_line": 65
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 | v: ty -> FStar.Sequence.Base.seq ty | Prims.Tot | [
"total"
] | [] | [
"Prims.Cons",
"Prims.Nil",
"FStar.Sequence.Base.seq"
] | [] | false | false | false | true | false | let singleton (#ty: Type) (v: ty) : seq ty =
| [v] | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.build | val build: #ty: Type -> seq ty -> ty -> seq ty | val build: #ty: Type -> seq ty -> ty -> seq ty | let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v] | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 18,
"end_line": 80,
"start_col": 0,
"start_line": 79
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 | s: FStar.Sequence.Base.seq ty -> v: ty -> FStar.Sequence.Base.seq ty | Prims.Tot | [
"total"
] | [] | [
"FStar.Sequence.Base.seq",
"FStar.List.Tot.Base.append",
"Prims.Cons",
"Prims.Nil"
] | [] | false | false | false | true | false | let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
| FLT.append s [v] | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.append | val append: #ty: Type -> seq ty -> seq ty -> seq ty | val append: #ty: Type -> seq ty -> seq ty -> seq ty | let append = FLT.append | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 23,
"end_line": 86,
"start_col": 0,
"start_line": 86
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 | _: FStar.Sequence.Base.seq ty -> _: FStar.Sequence.Base.seq ty -> FStar.Sequence.Base.seq ty | Prims.Tot | [
"total"
] | [] | [
"FStar.List.Tot.Base.append"
] | [] | false | false | false | true | false | let append =
| FLT.append | false |
FStar.Matrix.fst | FStar.Matrix.matrix_right_mul_identity_aux_0 | val matrix_right_mul_identity_aux_0
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: nat{k = 0})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth mx i k) ... | val matrix_right_mul_identity_aux_0
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: nat{k = 0})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth mx i k) ... | let matrix_right_mul_identity_aux_0 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=0}) ... | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 27,
"end_line": 790,
"start_col": 0,
"start_line": 781
} | (*
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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_modu... | {
"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 |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq {FStar.Matrix.is_absorber (CM?.unit add) mul} ->
mx: FStar.Matrix.matrix c m m ->
i: FStar.IntegerIntervals.under m ->
j: FStar.IntegerIntervals.under m ->
k: Prims.nat{k = 0}
-> FStar.Pervasives.Lemma
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"FStar.IntegerIntervals.under",
"Prims.nat",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FSt... | [] | true | false | true | false | false | let matrix_right_mul_identity_aux_0
#c
#eq
#m
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i: under m)
(j: under m)
(k: nat{k = 0})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: un... | eq.reflexivity add.unit | false |
Demo.Deps.fst | Demo.Deps.lbuffer | val lbuffer : len: FStar.UInt32.t -> a: Type0 -> Type0 | let lbuffer (len:U32.t) (a:Type) = b:B.buffer a{len <=^ length b} | {
"file_name": "examples/demos/low-star/Demo.Deps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 65,
"end_line": 74,
"start_col": 0,
"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",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.chec... | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"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 | len: FStar.UInt32.t -> a: Type0 -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.UInt32.t",
"LowStar.Buffer.buffer",
"Prims.b2t",
"FStar.UInt32.op_Less_Equals_Hat",
"Demo.Deps.length"
] | [] | false | false | false | true | true | let lbuffer (len: U32.t) (a: Type) =
| b: B.buffer a {len <=^ length b} | false | |
FStar.Sequence.Base.fst | FStar.Sequence.Base.take | val take: #ty: Type -> s: seq ty -> howMany: nat{howMany <= length s} -> seq ty | val take: #ty: Type -> s: seq ty -> howMany: nat{howMany <= length s} -> seq ty | let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 8,
"end_line": 109,
"start_col": 0,
"start_line": 107
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 | s: FStar.Sequence.Base.seq ty -> howMany: Prims.nat{howMany <= FStar.Sequence.Base.length s}
-> FStar.Sequence.Base.seq ty | Prims.Tot | [
"total"
] | [] | [
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"FStar.List.Tot.Base.splitAt"
] | [] | false | false | false | false | false | let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
| let result, _ = FLT.splitAt howMany s in
result | false |
Demo.Deps.fst | Demo.Deps.disjoint | val disjoint : b0: LowStar.Buffer.buffer 'a -> b1: LowStar.Buffer.buffer 'a -> Type0 | let disjoint (b0 b1:B.buffer 'a) = B.disjoint b0 b1 | {
"file_name": "examples/demos/low-star/Demo.Deps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 51,
"end_line": 72,
"start_col": 0,
"start_line": 72
} | (*
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",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.chec... | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"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 | b0: LowStar.Buffer.buffer 'a -> b1: LowStar.Buffer.buffer 'a -> Type0 | Prims.Tot | [
"total"
] | [] | [
"LowStar.Buffer.buffer",
"LowStar.Monotonic.Buffer.disjoint",
"LowStar.Buffer.trivial_preorder"
] | [] | false | false | false | true | true | let disjoint (b0 b1: B.buffer 'a) =
| B.disjoint b0 b1 | false | |
FStar.Sequence.Base.fst | FStar.Sequence.Base.drop | val drop: #ty: Type -> s: seq ty -> howMany: nat{howMany <= length s} -> seq ty | val drop: #ty: Type -> s: seq ty -> howMany: nat{howMany <= length s} -> seq ty | let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 8,
"end_line": 117,
"start_col": 0,
"start_line": 115
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 | s: FStar.Sequence.Base.seq ty -> howMany: Prims.nat{howMany <= FStar.Sequence.Base.length s}
-> FStar.Sequence.Base.seq ty | Prims.Tot | [
"total"
] | [] | [
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"FStar.List.Tot.Base.splitAt"
] | [] | false | false | false | false | false | let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
| let _, result = FLT.splitAt howMany s in
result | false |
FStar.Matrix.fst | FStar.Matrix.matrix_left_mul_identity_aux_0 | val matrix_left_mul_identity_aux_0
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: nat{k = 0})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth (matrix_m... | val matrix_left_mul_identity_aux_0
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: nat{k = 0})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth (matrix_m... | let matrix_left_mul_identity_aux_0 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=0})
: Lemma (ensures SP.f... | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 54,
"end_line": 917,
"start_col": 0,
"start_line": 910
} | (*
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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_modu... | {
"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 |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq {FStar.Matrix.is_absorber (CM?.unit add) mul} ->
mx: FStar.Matrix.matrix c m m ->
i: FStar.IntegerIntervals.under m ->
j: FStar.IntegerIntervals.under m ->
k: Prims.nat{k = 0}
-> FStar.Pervasives.Lemma
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"FStar.IntegerIntervals.under",
"Prims.nat",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FSt... | [] | true | false | true | false | false | let matrix_left_mul_identity_aux_0
#c
#eq
#m
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i: under m)
(j: under m)
(k: nat{k = 0})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: und... | eq.reflexivity add.unit | false |
FStar.Matrix.fst | FStar.Matrix.foldm_snoc_zero_lemma | val foldm_snoc_zero_lemma (#c #eq: _) (add: CE.cm c eq) (zeroes: SB.seq c)
: Lemma (requires (forall (i: under (SB.length zeroes)). (SB.index zeroes i) `eq.eq` add.unit))
(ensures eq.eq (SP.foldm_snoc add zeroes) add.unit)
(decreases SB.length zeroes) | val foldm_snoc_zero_lemma (#c #eq: _) (add: CE.cm c eq) (zeroes: SB.seq c)
: Lemma (requires (forall (i: under (SB.length zeroes)). (SB.index zeroes i) `eq.eq` add.unit))
(ensures eq.eq (SP.foldm_snoc add zeroes) add.unit)
(decreases SB.length zeroes) | let rec foldm_snoc_zero_lemma #c #eq (add: CE.cm c eq) (zeroes: SB.seq c)
: Lemma (requires (forall (i: under (SB.length zeroes)). SB.index zeroes i `eq.eq` add.unit))
(ensures eq.eq (SP.foldm_snoc add zeroes) add.unit)
(decreases SB.length zeroes) =
if (SB.length zeroes < 1) then begin
ass... | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 770,
"start_col": 0,
"start_line": 755
} | (*
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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_modu... | {
"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 | add: FStar.Algebra.CommMonoid.Equiv.cm c eq -> zeroes: FStar.Seq.Base.seq c
-> FStar.Pervasives.Lemma
(requires
forall (i: FStar.IntegerIntervals.under (FStar.Seq.Base.length zeroes)).
EQ?.eq eq (FStar.Seq.Base.index zeroes i) (CM?.unit add))
(ensures EQ?.eq eq (FStar.Seq.Permutation.fol... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Seq.Base.seq",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__reflexivity",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"Prims.unit",
"FStar.Pervasives.as... | [
"recursion"
] | false | false | true | false | false | let rec foldm_snoc_zero_lemma #c #eq (add: CE.cm c eq) (zeroes: SB.seq c)
: Lemma (requires (forall (i: under (SB.length zeroes)). (SB.index zeroes i) `eq.eq` add.unit))
(ensures eq.eq (SP.foldm_snoc add zeroes) add.unit)
(decreases SB.length zeroes) =
| if (SB.length zeroes < 1)
then
(assert_norm (SP.foldm_snoc add zeroes == add.unit);
eq.reflexivity add.unit)
else
let liat, last = SProp.un_snoc zeroes in
foldm_snoc_zero_lemma add liat;
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition ad... | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.contains | val contains: #ty: Type -> seq ty -> ty -> Type0 | val contains: #ty: Type -> seq ty -> ty -> Type0 | let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 14,
"end_line": 101,
"start_col": 0,
"start_line": 100
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 | s: FStar.Sequence.Base.seq ty -> v: ty -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Sequence.Base.seq",
"FStar.List.Tot.Base.memP"
] | [] | false | false | false | true | true | let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
| FLT.memP v s | false |
FStar.Matrix.fst | FStar.Matrix.matrix_mul_unit_row_lemma | val matrix_mul_unit_row_lemma (#c #eq m: _) (add mul: CE.cm c eq) (i: under m)
: Lemma
((row (matrix_mul_unit add mul m) i ==
(SB.create i add.unit)
`SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m - i - 1) add.unit))) /\
(row (matrix_mul_unit add mul m) i ==
(... | val matrix_mul_unit_row_lemma (#c #eq m: _) (add mul: CE.cm c eq) (i: under m)
: Lemma
((row (matrix_mul_unit add mul m) i ==
(SB.create i add.unit)
`SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m - i - 1) add.unit))) /\
(row (matrix_mul_unit add mul m) i ==
(... | let matrix_mul_unit_row_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((row (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(row (matrix_mul_unit add mul m) i
=... | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 54,
"end_line": 733,
"start_col": 0,
"start_line": 721
} | (*
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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_modu... | {
"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: Prims.nat ->
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
i: FStar.IntegerIntervals.under m
-> FStar.Pervasives.Lemma
(ensures
FStar.Matrix.row (FStar.Matrix.matrix_mul_unit add mul m) i ==
FStar.Seq.Base.append (FStar.Seq.Base.creat... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.nat",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.IntegerIntervals.under",
"FStar.Seq.Base.lemma_eq_elim",
"FStar.Seq.Base.append",
"FStar.Seq.Base.create",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"Prims.op_Subtraction",
"FStar.Matrix... | [] | true | false | true | false | false | let matrix_mul_unit_row_lemma #c #eq m (add: CE.cm c eq) (mul: CE.cm c eq) (i: under m)
: Lemma
((row (matrix_mul_unit add mul m) i ==
(SB.create i add.unit)
`SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m - i - 1) add.unit))) /\
(row (matrix_mul_unit add mul m) i ==
... | SB.lemma_eq_elim (((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit))
`SB.append`
(SB.create (m - i - 1) add.unit))
(row (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit)
`SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m - i - 1) add.unit)))
(row (matrix_mu... | false |
FStar.Matrix.fst | FStar.Matrix.matrix_right_identity_aux | val matrix_right_identity_aux
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: under (m + 1))
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth mx ... | val matrix_right_identity_aux
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: under (m + 1))
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth mx ... | let matrix_right_identity_aux #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1))
: Lemma (ensures S... | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 55,
"end_line": 908,
"start_col": 0,
"start_line": 895
} | (*
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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_modu... | {
"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 |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq {FStar.Matrix.is_absorber (CM?.unit add) mul} ->
mx: FStar.Matrix.matrix c m m ->
i: FStar.IntegerIntervals.under m ->
j: FStar.IntegerIntervals.under m ->
k: FStar.IntegerIntervals.under (m + 1)
-> FSt... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"FStar.IntegerIntervals.under",
"Prims.op_Addition",
"Prims.op_Equality",
"Prims.int",
"FStar.Matr... | [] | false | false | true | false | false | let matrix_right_identity_aux
#c
#eq
#m
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i: under m)
(j: under m)
(k: under (m + 1))
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (... | if k = 0
then matrix_right_mul_identity_aux_0 add mul mx i j k
else
if k <= j
then matrix_right_mul_identity_aux_1 add mul mx i j k
else
if k = j + 1
then matrix_right_mul_identity_aux_2 add mul mx i j k
else matrix_right_mul_identity_aux_3 add mul mx i j k | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.rank | val rank: #ty: Type -> ty -> ty | val rank: #ty: Type -> ty -> ty | let rank (#ty: Type) (v: ty) = v | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 32,
"end_line": 143,
"start_col": 0,
"start_line": 143
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 | v: ty -> ty | Prims.Tot | [
"total"
] | [] | [] | [] | false | false | false | true | false | let rank (#ty: Type) (v: ty) =
| v | false |
FStar.Matrix.fst | FStar.Matrix.matrix_mul_unit_col_lemma | val matrix_mul_unit_col_lemma (#c #eq m: _) (add mul: CE.cm c eq) (i: under m)
: Lemma
((col (matrix_mul_unit add mul m) i ==
(SB.create i add.unit)
`SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m - i - 1) add.unit))) /\
(col (matrix_mul_unit add mul m) i ==
(... | val matrix_mul_unit_col_lemma (#c #eq m: _) (add mul: CE.cm c eq) (i: under m)
: Lemma
((col (matrix_mul_unit add mul m) i ==
(SB.create i add.unit)
`SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m - i - 1) add.unit))) /\
(col (matrix_mul_unit add mul m) i ==
(... | let matrix_mul_unit_col_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((col (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(col (matrix_mul_unit add mul m) i ==
... | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 54,
"end_line": 747,
"start_col": 0,
"start_line": 735
} | (*
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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_modu... | {
"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: Prims.nat ->
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
i: FStar.IntegerIntervals.under m
-> FStar.Pervasives.Lemma
(ensures
FStar.Matrix.col (FStar.Matrix.matrix_mul_unit add mul m) i ==
FStar.Seq.Base.append (FStar.Seq.Base.creat... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.nat",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.IntegerIntervals.under",
"FStar.Seq.Base.lemma_eq_elim",
"FStar.Seq.Base.append",
"FStar.Seq.Base.create",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"Prims.op_Subtraction",
"FStar.Matrix... | [] | true | false | true | false | false | let matrix_mul_unit_col_lemma #c #eq m (add: CE.cm c eq) (mul: CE.cm c eq) (i: under m)
: Lemma
((col (matrix_mul_unit add mul m) i ==
(SB.create i add.unit)
`SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m - i - 1) add.unit))) /\
(col (matrix_mul_unit add mul m) i ==
... | SB.lemma_eq_elim (((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit))
`SB.append`
(SB.create (m - i - 1) add.unit))
(col (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit)
`SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m - i - 1) add.unit)))
(col (matrix_mu... | false |
FStar.Matrix.fst | FStar.Matrix.matrix_mul_left_identity | val matrix_mul_left_identity (#c:_) (#eq:_) (#m: pos) (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul (matrix_mul_unit add mul m) mx `(matrix_equiv eq m m).eq` mx) | val matrix_mul_left_identity (#c:_) (#eq:_) (#m: pos) (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul (matrix_mul_unit add mul m) mx `(matrix_equiv eq m m).eq` mx) | let matrix_mul_left_identity #c #eq #m (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul (matrix_mul_unit add mul m) mx `matrix_eq_fun eq` mx) =
let unit = matrix_mul_unit add mul m in
let m... | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 39,
"end_line": 1060,
"start_col": 0,
"start_line": 1046
} | (*
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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"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 |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq {FStar.Matrix.is_absorber (CM?.unit add) mul} ->
mx: FStar.Matrix.matrix c m m
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq (FStar.Matrix.matrix_equiv eq m m)
(FStar.Matrix.matrix_mul add mul (FStar.... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"FStar.Matrix.matrix_equiv_from_proof",
"FStar.IntegerIntervals.under",
"Prims.squash",
"FStar.Matri... | [] | false | false | true | false | false | let matrix_mul_left_identity
#c
#eq
#m
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_eq_fun eq (matrix_mul add mul (matrix_mul_unit add mul m) mx) mx) =
| let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul unit mx in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let aux (i j: under m) : squash (ijth mxu i j $=$ ijth mx i j) =
let gen (k: under m) = ijth unit i k * ijth mx k j in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul unit mx i j gen;
let ... | false |
FStar.Matrix.fst | FStar.Matrix.matrix_mul_identity | val matrix_mul_identity (#c:_) (#eq:_) (#m: pos) (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul mx (matrix_mul_unit add mul m) `(matrix_equiv eq m m).eq` mx /\
matrix_mul add mul (matrix_mul_unit... | val matrix_mul_identity (#c:_) (#eq:_) (#m: pos) (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul mx (matrix_mul_unit add mul m) `(matrix_equiv eq m m).eq` mx /\
matrix_mul add mul (matrix_mul_unit... | let matrix_mul_identity #c #eq #m (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul mx (matrix_mul_unit add mul m) `matrix_eq_fun eq` mx /\
matrix_mul add mul (matrix_mul_unit add mul m)... | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 1068,
"start_col": 0,
"start_line": 1062
} | (*
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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"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 |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq {FStar.Matrix.is_absorber (CM?.unit add) mul} ->
mx: FStar.Matrix.matrix c m m
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq (FStar.Matrix.matrix_equiv eq m m)
(FStar.Matrix.matrix_mul add mul mx (FSt... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"FStar.Matrix.matrix_mul_right_identity",
"Prims.unit",
"FStar.Matrix.matrix_mul_left_identity",
"Pr... | [] | true | false | true | false | false | let matrix_mul_identity
#c
#eq
#m
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma
(matrix_eq_fun eq (matrix_mul add mul mx (matrix_mul_unit add mul m)) mx /\
matrix_eq_fun eq (matrix_mul add mul (matrix_mul_unit add mul m) mx) m... | matrix_mul_left_identity add mul mx;
matrix_mul_right_identity add mul mx | false |
Steel.ST.HigherArray.fst | Steel.ST.HigherArray.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
= elim_pts_to a1 p x1;
elim_pts_to a2 p x2;
mk_carrier_merge (US.v (ptr_of a1).base_len) ((ptr_of a1).offset) x1 x2 (p);
change_r_pts_to
(ptr_of a2).base _
(ptr_of a1).base (mk_carrier (US.v (ptr_of a1).base_len) ((ptr_of a1).offset + Seq.length x1) x2 p);
R.gat... | {
"file_name": "lib/steel/Steel.ST.HigherArray.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 49,
"end_line": 521,
"start_col": 0,
"start_line": 507
} | (*
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": [
"Steel.ST.PCMReference.fsti.checked",
"Steel.ST.Loops.fsti.checked",
"Steel.PCMMap.fst.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.SizeT.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Rea... | [
{
"abbrev": true,
"full_module": "Steel.PCMMap",
"short_module": "PM"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "Steel.ST.PCMReference",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "Ste... | {
"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.HigherArray.array elt ->
a2: Steel.ST.HigherArray.array elt ->
h: Prims.squash (Steel.ST.HigherArray.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.HigherArray.array",
"Prims.squash",
"Steel.ST.HigherArray.adjacent",
"Steel.ST.HigherArray.intro_pts_to",
"Steel.ST.HigherArray.merge",
"FStar.Ghost.hide",
"Steel.ST.HigherArray.mk_carrier",
"FStar.SizeT.v"... | [] | false | true | false | false | false | let ghost_join #_ #_ #x1 #x2 #p a1 a2 h =
| elim_pts_to a1 p x1;
elim_pts_to a2 p x2;
mk_carrier_merge (US.v (ptr_of a1).base_len) ((ptr_of a1).offset) x1 x2 (p);
change_r_pts_to (ptr_of a2).base
_
(ptr_of a1).base
(mk_carrier (US.v (ptr_of a1).base_len) ((ptr_of a1).offset + Seq.length x1) x2 p);
R.gather (ptr_of a1).base
(mk_carrier (US.v (ptr_of a1).b... | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.index | val index: #ty: Type -> s: seq ty -> i: nat{i < length s} -> ty | val index: #ty: Type -> s: seq ty -> i: nat{i < length s} -> ty | let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 15,
"end_line": 73,
"start_col": 0,
"start_line": 72
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 | s: FStar.Sequence.Base.seq ty -> i: Prims.nat{i < FStar.Sequence.Base.length s} -> ty | Prims.Tot | [
"total"
] | [] | [
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"FStar.List.Tot.Base.index"
] | [] | false | false | false | false | false | let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
| FLT.index s i | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.equal | val equal: #ty: Type -> seq ty -> seq ty -> Type0 | val equal: #ty: Type -> seq ty -> seq ty -> Type0 | let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 59,
"end_line": 126,
"start_col": 0,
"start_line": 123
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 | s0: FStar.Sequence.Base.seq ty -> s1: FStar.Sequence.Base.seq ty -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Sequence.Base.seq",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"FStar.Sequence.Base.length",
"Prims.l_Forall",
"Prims.int",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Prims.op_LessThan",
"Prims.l_imp",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.index"
] | [] | false | false | false | true | true | let equal (#ty: Type) (s0 s1: seq ty) : Type0 =
| length s0 == length s1 /\
(forall j. {:pattern index s0 j\/index s1 j} 0 <= j && j < length s0 ==> index s0 j == index s1 j) | false |
Hacl.HPKE.Curve64_CP256_SHA512.fsti | Hacl.HPKE.Curve64_CP256_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.Curve64_CP256_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.Curve64_CP256_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": [
"Vale.X64.CPU_Features_s.fst.checked",
"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.fs... | [
{
"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.Matrix.fst | FStar.Matrix.matrix_left_identity_aux | val matrix_left_identity_aux
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: under (m + 1))
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth (mat... | val matrix_left_identity_aux
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: under (m + 1))
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth (mat... | let matrix_left_identity_aux #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1))
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k... | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 54,
"end_line": 1028,
"start_col": 0,
"start_line": 1016
} | (*
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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_modu... | {
"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 |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq {FStar.Matrix.is_absorber (CM?.unit add) mul} ->
mx: FStar.Matrix.matrix c m m ->
i: FStar.IntegerIntervals.under m ->
j: FStar.IntegerIntervals.under m ->
k: FStar.IntegerIntervals.under (m + 1)
-> FSt... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"FStar.IntegerIntervals.under",
"Prims.op_Addition",
"Prims.op_Equality",
"Prims.int",
"FStar.Matr... | [] | false | false | true | false | false | let matrix_left_identity_aux
#c
#eq
#m
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i: under m)
(j: under m)
(k: under (m + 1))
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k... | if k = 0
then matrix_left_mul_identity_aux_0 add mul mx i j k
else
if k <= i
then matrix_left_mul_identity_aux_1 add mul mx i j k
else
if k = i + 1
then matrix_left_mul_identity_aux_2 add mul mx i j k
else matrix_left_mul_identity_aux_3 add mul mx i j k | false |
FStar.Matrix.fst | FStar.Matrix.matrix_right_mul_identity_aux_1 | val matrix_right_mul_identity_aux_1
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: nat{k <= j})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth... | val matrix_right_mul_identity_aux_1
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: nat{k <= j})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth... | let rec matrix_right_mul_identity_aux_1 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k<=j... | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 30,
"end_line": 826,
"start_col": 0,
"start_line": 792
} | (*
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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_modu... | {
"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 |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq {FStar.Matrix.is_absorber (CM?.unit add) mul} ->
mx: FStar.Matrix.matrix c m m ->
i: FStar.IntegerIntervals.under m ->
j: FStar.IntegerIntervals.under m ->
k: Prims.nat{k <= j}
-> FStar.Pervasives.Lemma... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"FStar.IntegerIntervals.under",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Eq... | [
"recursion"
] | false | false | true | false | false | let rec matrix_right_mul_identity_aux_1
#c
#eq
#m
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i: under m)
(j: under m)
(k: nat{k <= j})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
... | if k = 0
then matrix_right_mul_identity_aux_0 add mul mx i j k
else
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat, last = SProp... | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.update | val update: #ty: Type -> s: seq ty -> i: nat{i < length s} -> ty -> seq ty | val update: #ty: Type -> s: seq ty -> i: nat{i < length s} -> ty -> seq ty | let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 27,
"end_line": 94,
"start_col": 0,
"start_line": 92
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 | s: FStar.Sequence.Base.seq ty -> i: Prims.nat{i < FStar.Sequence.Base.length s} -> v: ty
-> FStar.Sequence.Base.seq ty | Prims.Tot | [
"total"
] | [] | [
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"Prims.list",
"FStar.Sequence.Base.append",
"Prims.Cons",
"Prims.Nil",
"FStar.Pervasives.Native.tuple3",
"FStar.List.Tot.Base.split3"
] | [] | false | false | false | false | false | let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
| let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2) | false |
FStar.Matrix.fst | FStar.Matrix.dot_of_equal_sequences | val dot_of_equal_sequences
(#c #eq: _)
(add mul: CE.cm c eq)
(m: _)
(p q r s: (z: SB.seq c {SB.length z == m}))
: Lemma (requires eq_of_seq eq p r /\ eq_of_seq eq q s)
(ensures eq.eq (dot add mul p q) (dot add mul r s)) | val dot_of_equal_sequences
(#c #eq: _)
(add mul: CE.cm c eq)
(m: _)
(p q r s: (z: SB.seq c {SB.length z == m}))
: Lemma (requires eq_of_seq eq p r /\ eq_of_seq eq q s)
(ensures eq.eq (dot add mul p q) (dot add mul r s)) | let dot_of_equal_sequences #c #eq (add mul: CE.cm c eq) m
(p q r s: (z:SB.seq c{SB.length z == m}))
: Lemma (requires eq_of_seq eq p r /\ eq_of_seq eq q s)
(ensures eq.eq (dot add mul p q) (dot add mul r s)) =
eq_of_seq_element_equality eq p r;
eq_of_seq_element_equal... | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 80,
"end_line": 1081,
"start_col": 0,
"start_line": 1070
} | (*
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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_modu... | {
"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 |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
m: Prims.nat ->
p: z: FStar.Seq.Base.seq c {FStar.Seq.Base.length z == m} ->
q: z: FStar.Seq.Base.seq c {FStar.Seq.Base.length z == m} ->
r: z: FStar.Seq.Base.seq c {FStar.Seq.Base.length z == m} ->
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"Prims.nat",
"FStar.Seq.Base.seq",
"Prims.eq2",
"FStar.Seq.Base.length",
"FStar.Seq.Permutation.foldm_snoc_equality",
"FStar.Matrix.seq_of_products",
"Prims.unit",
"FStar.Seq.Equiv.eq_of_seq_from_element_equality",
"FSt... | [] | false | false | true | false | false | let dot_of_equal_sequences
#c
#eq
(add: CE.cm c eq)
(mul: CE.cm c eq)
m
(p: (z: SB.seq c {SB.length z == m}))
(q: (z: SB.seq c {SB.length z == m}))
(r: (z: SB.seq c {SB.length z == m}))
(s: (z: SB.seq c {SB.length z == m}))
: Lemma (requires eq_of_seq eq p r /\ ... | eq_of_seq_element_equality eq p r;
eq_of_seq_element_equality eq q s;
let aux (i: under (SB.length p))
: Lemma ((SB.index (seq_of_products mul p q) i) `eq.eq` (SB.index (seq_of_products mul r s) i))
=
mul.congruence (SB.index p i) (SB.index q i) (SB.index r i) (SB.index s i)
in
Classical.forall_intro aux;
eq_of_s... | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.is_prefix | val is_prefix: #ty: Type -> seq ty -> seq ty -> Type0 | val is_prefix: #ty: Type -> seq ty -> seq ty -> Type0 | let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 48,
"end_line": 137,
"start_col": 0,
"start_line": 134
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 | s0: FStar.Sequence.Base.seq ty -> s1: FStar.Sequence.Base.seq ty -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Sequence.Base.seq",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.op_LessThan",
"Prims.eq2",
"FStar.Sequence.Base.index"
] | [] | false | false | false | true | true | let is_prefix (#ty: Type) (s0 s1: seq ty) : Type0 =
| length s0 <= length s1 /\
(forall (j: nat). {:pattern index s0 j\/index s1 j} j < length s0 ==> index s0 j == index s1 j) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_right_mul_identity_aux_3 | val matrix_right_mul_identity_aux_3
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: under (m + 1) {k > j + 1})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: und... | val matrix_right_mul_identity_aux_3
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: under (m + 1) {k > j + 1})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: und... | let rec matrix_right_mul_identity_aux_3 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1)... | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 31,
"end_line": 893,
"start_col": 0,
"start_line": 859
} | (*
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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_modu... | {
"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 |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq {FStar.Matrix.is_absorber (CM?.unit add) mul} ->
mx: FStar.Matrix.matrix c m m ->
i: FStar.IntegerIntervals.under m ->
j: FStar.IntegerIntervals.under m ->
k: FStar.IntegerIntervals.under (m + 1) {k > j +... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"FStar.IntegerIntervals.under",
"Prims.op_Addition",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.S... | [
"recursion"
] | false | false | true | false | false | let rec matrix_right_mul_identity_aux_3
#c
#eq
#m
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i: under m)
(j: under m)
(k: under (m + 1) {k > j + 1})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
... | if (k - 1) > j + 1
then matrix_right_mul_identity_aux_3 add mul mx i j (k - 1)
else matrix_right_mul_identity_aux_2 add mul mx i j (k - 1);
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit... | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.append_sums_lengths_lemma | val append_sums_lengths_lemma: Prims.unit -> Lemma (append_sums_lengths_fact) | val append_sums_lengths_lemma: Prims.unit -> Lemma (append_sums_lengths_fact) | let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 188,
"start_col": 8,
"start_line": 184
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 FStar.Sequence.Base.append_sums_lengths_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Sequence.Base.length",
"FStar.Sequence.Base.append",
"Prims.op_Addition",
"FStar.List.Tot.Properties.append_length",
"Prims.squash",
"Prims.l... | [] | false | false | true | false | false | let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
| introduce forall (ty: Type) (s0: seq ty) (s1: seq ty) . length (append s0 s1) =
length s0 + length s1
with (FLT.append_length s0 s1) | false |
Demo.Deps.fst | Demo.Deps.length | val length (#a: Type) (b: buffer a) : GTot U32.t | val length (#a: Type) (b: buffer a) : GTot U32.t | let length (#a:Type) (b:buffer a) : GTot U32.t =
U32.uint_to_t (B.length b) | {
"file_name": "examples/demos/low-star/Demo.Deps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 30,
"end_line": 33,
"start_col": 0,
"start_line": 32
} | (*
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",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.chec... | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"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 | b: Demo.Deps.buffer a -> Prims.GTot FStar.UInt32.t | Prims.GTot | [
"sometrivial"
] | [] | [
"Demo.Deps.buffer",
"FStar.UInt32.uint_to_t",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t"
] | [] | false | false | false | false | false | let length (#a: Type) (b: buffer a) : GTot U32.t =
| U32.uint_to_t (B.length b) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_mul_right_identity | val matrix_mul_right_identity (#c:_) (#eq:_) (#m: pos) (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul mx (matrix_mul_unit add mul m) `(matrix_equiv eq m m).eq` mx) | val matrix_mul_right_identity (#c:_) (#eq:_) (#m: pos) (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul mx (matrix_mul_unit add mul m) `(matrix_equiv eq m m).eq` mx) | let matrix_mul_right_identity #c #eq #m (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul mx (matrix_mul_unit add mul m) `matrix_eq_fun eq` mx) =
let unit = matrix_mul_unit add mul m in
let ... | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 40,
"end_line": 1044,
"start_col": 0,
"start_line": 1030
} | (*
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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"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 |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq {FStar.Matrix.is_absorber (CM?.unit add) mul} ->
mx: FStar.Matrix.matrix c m m
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq (FStar.Matrix.matrix_equiv eq m m)
(FStar.Matrix.matrix_mul add mul mx (FSt... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"FStar.Matrix.matrix_equiv_from_element_eq",
"Prims.unit",
"FStar.Classical.forall_intro_2",
"FStar.... | [] | false | false | true | false | false | let matrix_mul_right_identity
#c
#eq
#m
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_eq_fun eq (matrix_mul add mul mx (matrix_mul_unit add mul m)) mx) =
| let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let aux (i j: under m) : Lemma (ijth mxu i j $=$ ijth mx i j) =
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx unit i j gen;
... | false |
FStar.Matrix.fst | FStar.Matrix.matrix_mul_is_left_distributive | val matrix_mul_is_left_distributive (#c:_) (#eq:_) (#m #n #p:pos) (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my mz: matrix c n p)
: Lemma (matrix_mul add mul mx (matrix_add ... | val matrix_mul_is_left_distributive (#c:_) (#eq:_) (#m #n #p:pos) (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my mz: matrix c n p)
: Lemma (matrix_mul add mul mx (matrix_add ... | let matrix_mul_is_left_distributive #c #eq #m #n #p (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my mz: matrix c n p)
: Lemma (matrix_mul add mul mx (matrix_add add my mz) `ma... | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 43,
"end_line": 1137,
"start_col": 0,
"start_line": 1106
} | (*
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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"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 |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul:
FStar.Algebra.CommMonoid.Equiv.cm c eq
{FStar.Matrix.is_fully_distributive mul add /\ FStar.Matrix.is_absorber (CM?.unit add) mul} ->
mx: FStar.Matrix.matrix c m n ->
my: FStar.Matrix.matrix c n p ->
mz: FStar.Matrix.matrix c n p
-... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"Prims.l_and",
"FStar.Matrix.is_fully_distributive",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"FStar.Matrix.matrix_equiv_from_proof",
"FStar.... | [] | false | false | true | false | false | let matrix_mul_is_left_distributive
#c
#eq
#m
#n
#p
(add: CE.cm c eq)
(mul: CE.cm c eq {is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n)
(my: matrix c n p)
(mz: matrix c n p)
: Lemma
(matrix_eq_fun eq
(matrix_mul a... | let myz = matrix_add add my mz in
let mxy = matrix_mul add mul mx my in
let mxz = matrix_mul add mul mx mz in
let lhs = matrix_mul add mul mx myz in
let rhs = matrix_add add mxy mxz in
let sum_j (f: (under n -> c)) = SP.foldm_snoc add (SB.init n f) in
let sum_k (f: (under p -> c)) = SP.foldm_snoc add (SB.init p f) in
l... | false |
Demo.Deps.fst | Demo.Deps.suffix | val suffix (#a: Type) (b: buffer a) (from: U32.t) (len: U32.t{len <=^ length b /\ from <=^ len})
: ST (buffer a)
(requires (fun h -> U32.v from + U32.v len <= U32.v (length b) /\ live h b))
(ensures (fun h y h' -> h == h' /\ y == mgsub _ b from (len -^ from))) | val suffix (#a: Type) (b: buffer a) (from: U32.t) (len: U32.t{len <=^ length b /\ from <=^ len})
: ST (buffer a)
(requires (fun h -> U32.v from + U32.v len <= U32.v (length b) /\ live h b))
(ensures (fun h y h' -> h == h' /\ y == mgsub _ b from (len -^ from))) | let suffix (#a:Type)
(b:buffer a)
(from:U32.t)
(len:U32.t{len <=^ length b /\ from <=^ len})
: ST (buffer a)
(requires (fun h ->
U32.v from + U32.v len <= U32.v (length b) /\
live h b))
(ensures (fun h y h' -> h == h' /\ y == mgsub _ b from (len -^ ... | {
"file_name": "examples/demos/low-star/Demo.Deps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 30,
"end_line": 69,
"start_col": 0,
"start_line": 60
} | (*
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",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.chec... | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"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 |
b: Demo.Deps.buffer a ->
from: FStar.UInt32.t ->
len: FStar.UInt32.t{len <=^ Demo.Deps.length b /\ from <=^ len}
-> FStar.HyperStack.ST.ST (Demo.Deps.buffer a) | FStar.HyperStack.ST.ST | [] | [] | [
"Demo.Deps.buffer",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"FStar.UInt32.op_Less_Equals_Hat",
"Demo.Deps.length",
"LowStar.Buffer.sub",
"FStar.Ghost.hide",
"FStar.UInt32.op_Subtraction_Hat",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"FStar.Monotonic.HyperSta... | [] | false | true | false | false | false | let suffix (#a: Type) (b: buffer a) (from: U32.t) (len: U32.t{len <=^ length b /\ from <=^ len})
: ST (buffer a)
(requires (fun h -> U32.v from + U32.v len <= U32.v (length b) /\ live h b))
(ensures (fun h y h' -> h == h' /\ y == mgsub _ b from (len -^ from))) =
| B.sub b from (len -^ from) | false |
Demo.Deps.fst | Demo.Deps.op_Subtraction | val op_Subtraction : x: FStar.UInt32.t ->
y: FStar.UInt32.t{FStar.UInt.size (FStar.UInt32.v x - FStar.UInt32.v y) FStar.UInt32.n}
-> FStar.UInt32.t | let op_Subtraction (x:U32.t)
(y:U32.t{FStar.UInt.size (v x - v y) U32.n})
= U32.(x -^ y) | {
"file_name": "examples/demos/low-star/Demo.Deps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 33,
"end_line": 97,
"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",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.chec... | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"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 |
x: FStar.UInt32.t ->
y: FStar.UInt32.t{FStar.UInt.size (FStar.UInt32.v x - FStar.UInt32.v y) FStar.UInt32.n}
-> FStar.UInt32.t | Prims.Tot | [
"total"
] | [] | [
"FStar.UInt32.t",
"FStar.UInt.size",
"Prims.op_Subtraction",
"FStar.UInt32.v",
"FStar.UInt32.n",
"FStar.UInt32.op_Subtraction_Hat"
] | [] | false | false | false | false | false | let ( - ) (x: U32.t) (y: U32.t{FStar.UInt.size (v x - v y) U32.n}) =
| let open U32 in x -^ y | false | |
Hacl.Impl.Ed25519.Ladder.fst | Hacl.Impl.Ed25519.Ladder.point_mul_noalloc | val point_mul_noalloc:
out:point
-> bscalar:lbuffer uint64 4ul
-> q:point ->
Stack unit
(requires fun h ->
live h bscalar /\ live h q /\ live h out /\
disjoint q out /\ disjoint q bscalar /\ disjoint out bscalar /\
F51.point_inv_t h q /\ F51.inv_ext_point (as_seq h q) /\
BD.bn_v h bscalar < ... | val point_mul_noalloc:
out:point
-> bscalar:lbuffer uint64 4ul
-> q:point ->
Stack unit
(requires fun h ->
live h bscalar /\ live h q /\ live h out /\
disjoint q out /\ disjoint q bscalar /\ disjoint out bscalar /\
F51.point_inv_t h q /\ F51.inv_ext_point (as_seq h q) /\
BD.bn_v h bscalar < ... | let point_mul_noalloc out bscalar q =
BE.lexp_fw_consttime 20ul 0ul mk_ed25519_concrete_ops
4ul (null uint64) q 4ul 256ul bscalar out | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Ladder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 45,
"end_line": 85,
"start_col": 0,
"start_line": 83
} | module Hacl.Impl.Ed25519.Ladder
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module BSeq = Lib.ByteSequence
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module BE = Hacl.Impl... | {
"checked_file": "/",
"dependencies": [
"Spec.Exponentiation.fsti.checked",
"Spec.Ed25519.Lemmas.fsti.checked",
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"LowStar.Ignore.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.chec... | [
{
"abbrev": false,
"full_module": "Hacl.Ed25519.PrecompTable",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519.Group",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519.PointConstants",
"short_module": null
},
{
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"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 |
out: Hacl.Bignum25519.point ->
bscalar: Lib.Buffer.lbuffer Lib.IntTypes.uint64 4ul ->
q: Hacl.Bignum25519.point
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Bignum25519.point",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.Exponentiation.lexp_fw_consttime",
"Lib.IntTypes.U64",
"Hacl.Impl.Ed25519.Group.mk_ed25519_concrete_ops",
"Lib.Buffer.null",
"Lib.Buffer.MUT",
"Prims.unit"
] | [] | false | true | false | false | false | let point_mul_noalloc out bscalar q =
| BE.lexp_fw_consttime 20ul 0ul mk_ed25519_concrete_ops 4ul (null uint64) q 4ul 256ul bscalar out | false |
Demo.Deps.fst | Demo.Deps.free | val free (#a: Type0) (b: buffer a)
: ST unit
(requires fun h0 -> live h0 b /\ freeable b)
(ensures
(fun h0 _ h1 ->
(Map.domain (HS.get_hmap h1)) `Set.equal` (Map.domain (HS.get_hmap h0)) /\
(HS.get_tip h1) == (HS.get_tip h0) /\ B.modifies (loc_addr_of_buffer b) h0 h1 /\
... | val free (#a: Type0) (b: buffer a)
: ST unit
(requires fun h0 -> live h0 b /\ freeable b)
(ensures
(fun h0 _ h1 ->
(Map.domain (HS.get_hmap h1)) `Set.equal` (Map.domain (HS.get_hmap h0)) /\
(HS.get_tip h1) == (HS.get_tip h0) /\ B.modifies (loc_addr_of_buffer b) h0 h1 /\
... | let free (#a:Type0) (b:buffer a)
: ST unit
(requires fun h0 ->
live h0 b /\
freeable b)
(ensures (fun h0 _ h1 ->
Map.domain (HS.get_hmap h1) `Set.equal` Map.domain (HS.get_hmap h0) /\
(HS.get_tip h1) == (HS.get_tip h0) /\
B.modifies (loc_addr_of_buffer b) h... | {
"file_name": "examples/demos/low-star/Demo.Deps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 11,
"end_line": 117,
"start_col": 0,
"start_line": 107
} | (*
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",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.chec... | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"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 | b: Demo.Deps.buffer a -> FStar.HyperStack.ST.ST Prims.unit | FStar.HyperStack.ST.ST | [] | [] | [
"Demo.Deps.buffer",
"LowStar.Monotonic.Buffer.free",
"LowStar.Buffer.trivial_preorder",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Demo.Deps.live",
"LowStar.Monotonic.Buffer.freeable",
"FStar.Set.equal",
"FStar.Monotonic.HyperHeap.rid",
"FStar.Map.domain",
"FStar.Monotonic... | [] | false | true | false | false | false | let free (#a: Type0) (b: buffer a)
: ST unit
(requires fun h0 -> live h0 b /\ freeable b)
(ensures
(fun h0 _ h1 ->
(Map.domain (HS.get_hmap h1)) `Set.equal` (Map.domain (HS.get_hmap h0)) /\
(HS.get_tip h1) == (HS.get_tip h0) /\ B.modifies (loc_addr_of_buffer b) h0 h1 /\
... | B.free b | false |
Demo.Deps.fst | Demo.Deps.prefix_equal | val prefix_equal (#l: uint32) (#a: Type) (h: HS.mem) (b1 b2: lbuffer l a) (i: uint32{i <=^ l})
: prop | val prefix_equal (#l: uint32) (#a: Type) (h: HS.mem) (b1 b2: lbuffer l a) (i: uint32{i <=^ l})
: prop | let prefix_equal (#l:uint32) (#a:Type)
(h:HS.mem)
(b1 b2: lbuffer l a)
(i:uint32{i <=^ l})
: prop
= forall (j:uint32). j <^ i ==>
B.get h b1 (U32.v j) == B.get h b2 (U32.v j) | {
"file_name": "examples/demos/low-star/Demo.Deps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 62,
"end_line": 82,
"start_col": 0,
"start_line": 76
} | (*
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",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.chec... | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"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 |
h: FStar.Monotonic.HyperStack.mem ->
b1: Demo.Deps.lbuffer l a ->
b2: Demo.Deps.lbuffer l a ->
i: Demo.Deps.uint32{i <=^ l}
-> Prims.prop | Prims.Tot | [
"total"
] | [] | [
"Demo.Deps.uint32",
"FStar.Monotonic.HyperStack.mem",
"Demo.Deps.lbuffer",
"Prims.b2t",
"FStar.UInt32.op_Less_Equals_Hat",
"Prims.l_Forall",
"Prims.l_imp",
"FStar.UInt32.op_Less_Hat",
"Prims.eq2",
"LowStar.Monotonic.Buffer.get",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.v",
"Prims.pro... | [] | false | false | false | false | true | let prefix_equal (#l: uint32) (#a: Type) (h: HS.mem) (b1 b2: lbuffer l a) (i: uint32{i <=^ l})
: prop =
| forall (j: uint32). j <^ i ==> B.get h b1 (U32.v j) == B.get h b2 (U32.v j) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.update_maintains_length_lemma | val update_maintains_length_lemma: Prims.unit -> Lemma (update_maintains_length_fact) | val update_maintains_length_lemma: Prims.unit -> Lemma (update_maintains_length_fact) | let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 231,
"start_col": 8,
"start_line": 226
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 FStar.Sequence.Base.update_maintains_length_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"Prims.op_Equality",
"FStar.Sequence.Base.update",
"FStar.Sequence.Base.update_maintains_length_helper",
"Prims.squash",... | [] | false | false | true | false | false | let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
| introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) . length (update s i v) =
length s
with (update_maintains_length_helper s i v) | false |
FStar.Matrix.fst | FStar.Matrix.double_foldm_snoc_transpose_lemma | val double_foldm_snoc_transpose_lemma
(#c #eq: _)
(#m #n: pos)
(cm: CE.cm c eq)
(f: (under m -> under n -> c))
: Lemma
((SP.foldm_snoc cm
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
)
`eq.eq`
(SP.foldm_snoc cm
... | val double_foldm_snoc_transpose_lemma
(#c #eq: _)
(#m #n: pos)
(cm: CE.cm c eq)
(f: (under m -> under n -> c))
: Lemma
((SP.foldm_snoc cm
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
)
`eq.eq`
(SP.foldm_snoc cm
... | let double_foldm_snoc_transpose_lemma #c #eq (#m #n: pos) (cm: CE.cm c eq) (f: under m -> under n -> c)
: Lemma (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (... | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 126,
"end_line": 642,
"start_col": 0,
"start_line": 606
} | (*
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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_modu... | {
"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 |
cm: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
f: (_: FStar.IntegerIntervals.under m -> _: FStar.IntegerIntervals.under n -> c)
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(FStar.Seq.Permutation.foldm_snoc cm
(FStar.Seq.Base.init m
(fun i ->
F... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.IntegerIntervals.under",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__transitivity",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.Seq.Base.init",
"FStar.Matrix.foldm",
"Prims.unit",
"Prims._assert",... | [] | false | false | true | false | false | let double_foldm_snoc_transpose_lemma
#c
#eq
(#m: pos)
(#n: pos)
(cm: CE.cm c eq)
(f: (under m -> under n -> c))
: Lemma
((SP.foldm_snoc cm
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
)
`eq.eq`
(SP.fol... | Classical.forall_intro_2 (Classical.move_requires_2 eq.symmetry);
let gen:matrix_generator c m n = f in
let mx = init gen in
let mx_seq = matrix_seq gen in
matrix_fold_equals_fold_of_seq_folds cm gen;
let aux (i: under m) : Lemma (SB.init n (gen i) == SB.init n (fun (j: under n) -> f i j)) =
SB.lemma_eq_elim (SB.init... | false |
FStar.Matrix.fst | FStar.Matrix.matrix_left_mul_identity_aux_1 | val matrix_left_mul_identity_aux_1
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: nat{k <= i /\ k > 0})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth... | val matrix_left_mul_identity_aux_1
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: nat{k <= i /\ k > 0})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth... | let rec matrix_left_mul_identity_aux_1 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k<=i /\ k... | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 26,
"end_line": 947,
"start_col": 0,
"start_line": 919
} | (*
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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_modu... | {
"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 |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq {FStar.Matrix.is_absorber (CM?.unit add) mul} ->
mx: FStar.Matrix.matrix c m m ->
i: FStar.IntegerIntervals.under m ->
j: FStar.IntegerIntervals.under m ->
k: Prims.nat{k <= i /\ k > 0}
-> FStar.Pervasi... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"FStar.IntegerIntervals.under",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual... | [
"recursion"
] | false | false | true | false | false | let rec matrix_left_mul_identity_aux_1
#c
#eq
#m
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i: under m)
(j: under m)
(k: nat{k <= i /\ k > 0})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
... | let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
let liat, last = SProp.un_snoc full in
if k = 1
then matrix_left_mul_identity_aux_0 add mul mx i j (k - 1)
else... | false |
Demo.Deps.fst | Demo.Deps.get | val get : h: FStar.Monotonic.HyperStack.mem ->
b: Demo.Deps.buffer 'a {Demo.Deps.live h b} ->
i: FStar.UInt32.t{i < Demo.Deps.length b}
-> Prims.GTot 'a | let get (h:HS.mem) (b:buffer 'a{ live h b }) (i:U32.t{ i < length b}) =
B.get h b (U32.v i) | {
"file_name": "examples/demos/low-star/Demo.Deps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 21,
"end_line": 120,
"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",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.chec... | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"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 |
h: FStar.Monotonic.HyperStack.mem ->
b: Demo.Deps.buffer 'a {Demo.Deps.live h b} ->
i: FStar.UInt32.t{i < Demo.Deps.length b}
-> Prims.GTot 'a | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"Demo.Deps.buffer",
"Demo.Deps.live",
"FStar.UInt32.t",
"Prims.b2t",
"Demo.Deps.op_Less",
"Demo.Deps.length",
"LowStar.Monotonic.Buffer.get",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.v"
] | [] | false | false | false | false | false | let get (h: HS.mem) (b: buffer 'a {live h b}) (i: U32.t{i < length b}) =
| B.get h b (U32.v i) | false | |
Demo.Deps.fst | Demo.Deps.malloc | val malloc (init: 'a) (len: U32.t)
: ST (lbuffer len 'a)
(requires fun h -> malloc_pre HS.root len)
(ensures
fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init) /\ freeable b) | val malloc (init: 'a) (len: U32.t)
: ST (lbuffer len 'a)
(requires fun h -> malloc_pre HS.root len)
(ensures
fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init) /\ freeable b) | let malloc (init:'a) (len:U32.t)
: ST (lbuffer len 'a)
(requires fun h -> malloc_pre HS.root len)
(ensures fun h0 b h1 ->
alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init) /\
freeable b)
= B.malloc HS.root init len | {
"file_name": "examples/demos/low-star/Demo.Deps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 29,
"end_line": 105,
"start_col": 0,
"start_line": 99
} | (*
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",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.chec... | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"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 | init: 'a -> len: FStar.UInt32.t -> FStar.HyperStack.ST.ST (Demo.Deps.lbuffer len 'a) | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.UInt32.t",
"LowStar.Buffer.malloc",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.UInt32.v",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monoton... | [] | false | true | false | false | false | let malloc (init: 'a) (len: U32.t)
: ST (lbuffer len 'a)
(requires fun h -> malloc_pre HS.root len)
(ensures
fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init) /\ freeable b) =
| B.malloc HS.root init len | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.build_contains_equiv_lemma | val build_contains_equiv_lemma: Prims.unit -> Lemma (build_contains_equiv_fact) | val build_contains_equiv_lemma: Prims.unit -> Lemma (build_contains_equiv_fact) | let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 296,
"start_col": 8,
"start_line": 290
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 FStar.Sequence.Base.build_contains_equiv_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.l_iff",
"FStar.Sequence.Base.contains",
"FStar.Sequence.Base.build",
"Prims.l_or",
"Prims.eq2",
"FStar.Sequence.Base.build_contains_equiv_helper",
"Prims.squash",
"Prims.l_True",
"FStar.Se... | [] | false | false | true | false | false | let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
| introduce forall (ty: Type) (s: seq ty) (v: ty) (x: ty) . contains (build s v) x <==>
(v == x \/ contains s x)
with (build_contains_equiv_helper ty s v x) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.take_contains_equiv_exists_lemma | val take_contains_equiv_exists_lemma: Prims.unit -> Lemma (take_contains_equiv_exists_fact) | val take_contains_equiv_exists_lemma: Prims.unit -> Lemma (take_contains_equiv_exists_fact) | let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (
take_contains_equiv_exists_helper3... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 346,
"start_col": 8,
"start_line": 340
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 FStar.Sequence.Base.take_contains_equiv_exists_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.l_iff",
"FStar.Sequence.Base.contains",
"FStar.Sequence.Base.take",
"Prims.l_Exists",
"Prims.l_and",
"... | [] | false | false | true | false | false | let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
| introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty) . contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (take_contains_equiv_exists_helper3 ty s n x) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.index_after_append_lemma | val index_after_append_lemma: squash (append_sums_lengths_fact u#a)
-> Lemma (index_after_append_fact u#a ()) | val index_after_append_lemma: squash (append_sums_lengths_fact u#a)
-> Lemma (index_after_append_fact u#a ()) | let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append ... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 207,
"start_col": 8,
"start_line": 200
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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.squash FStar.Sequence.Base.append_sums_lengths_fact
-> FStar.Pervasives.Lemma (ensures FStar.Sequence.Base.index_after_append_fact ()) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.squash",
"FStar.Sequence.Base.append_sums_lengths_fact",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"FStar.Sequence.Base.append",
"Prims.l_and",
"Prims.l_imp",
"Prims.e... | [] | false | false | true | false | false | let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a))
: Lemma (index_after_append_fact u#a ()) =
| introduce forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}) . (n <
length s0 ==>
index (append s0 s1) n == index s0 n) /\
(length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (index_after_append_helper ty s0 s1 n) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.build_increments_length_lemma | val build_increments_length_lemma: Prims.unit -> Lemma (build_increments_length_fact) | val build_increments_length_lemma: Prims.unit -> Lemma (build_increments_length_fact) | let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 163,
"start_col": 8,
"start_line": 159
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 FStar.Sequence.Base.build_increments_length_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Sequence.Base.length",
"FStar.Sequence.Base.build",
"Prims.op_Addition",
"FStar.List.Tot.Properties.append_length",
"Prims.Cons",
"Prims.Nil"... | [] | false | false | true | false | false | let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
| introduce forall (ty: Type) (s: seq ty) (v: ty) . length (build s v) = 1 + length s
with (FLT.append_length s [v]) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.lemma_splitAt_fst_length | val lemma_splitAt_fst_length (#a: Type) (n: nat) (l: list a)
: Lemma (requires (n <= length l)) (ensures (length (fst (FLT.splitAt n l)) = n)) | val lemma_splitAt_fst_length (#a: Type) (n: nat) (l: list a)
: Lemma (requires (n <= length l)) (ensures (length (fst (FLT.splitAt n l)) = n)) | let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l' | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 53,
"end_line": 216,
"start_col": 8,
"start_line": 209
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 | n: Prims.nat -> l: Prims.list a
-> FStar.Pervasives.Lemma (requires n <= FStar.Sequence.Base.length l)
(ensures
FStar.Sequence.Base.length (FStar.Pervasives.Native.fst (FStar.List.Tot.Base.splitAt n l)) =
n) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"Prims.list",
"FStar.Pervasives.Native.Mktuple2",
"Prims.int",
"FStar.Sequence.Base.lemma_splitAt_fst_length",
"Prims.op_Subtraction",
"Prims.unit",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.squash",
"Prims.op_Equality",
"FStar.Pervasives.Nati... | [
"recursion"
] | false | false | true | false | false | let rec lemma_splitAt_fst_length (#a: Type) (n: nat) (l: list a)
: Lemma (requires (n <= length l)) (ensures (length (fst (FLT.splitAt n l)) = n)) =
| match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l' | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.build_contains_equiv_helper | val build_contains_equiv_helper (ty: Type) (s: list ty) (v x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) | val build_contains_equiv_helper (ty: Type) (s: list ty) (v x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) | let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 49,
"end_line": 288,
"start_col": 8,
"start_line": 280
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 | ty: Type -> s: Prims.list ty -> v: ty -> x: ty
-> FStar.Pervasives.Lemma
(ensures
FStar.List.Tot.Base.memP x (FStar.Sequence.Base.append s [v]) <==>
v == x \/ FStar.List.Tot.Base.memP x s) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"FStar.Classical.Sugar.or_elim",
"Prims.eq2",
"Prims.squash",
"Prims.l_not",
"Prims.l_iff",
"FStar.List.Tot.Base.memP",
"FStar.Sequence.Base.append",
"Prims.Cons",
"Prims.Nil",
"Prims.l_or",
"FStar.Sequence.Base.build_contains_equiv_helper",
"Prims.unit",
"Prims.l_True",
"F... | [
"recursion"
] | false | false | true | false | false | let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
| match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _ . ()
and _ . build_contains_equiv_helper ty tl v x | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.take_contains_equiv_exists_helper2 | val take_contains_equiv_exists_helper2
(ty: Type)
(s: list ty)
(n: nat{n <= length s})
(x: ty)
(i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x)) (ensures FLT.memP x (take s n)) | val take_contains_equiv_exists_helper2
(ty: Type)
(s: list ty)
(n: nat{n <= length s})
(x: ty)
(i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x)) (ensures FLT.memP x (take s n)) | let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 81,
"end_line": 324,
"start_col": 8,
"start_line": 316
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 |
ty: Type ->
s: Prims.list ty ->
n: Prims.nat{n <= FStar.Sequence.Base.length s} ->
x: ty ->
i: Prims.nat
-> FStar.Pervasives.Lemma
(requires i < n /\ i < FStar.Sequence.Base.length s /\ FStar.Sequence.Base.index s i == x)
(ensures FStar.List.Tot.Base.memP x (FStar.Sequence.Base.take s... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"FStar.Classical.Sugar.or_elim",
"Prims.eq2",
"Prims.squash",
"Prims.l_not",
"FStar.List.Tot.Base.memP",
"FStar.Sequence.Base.take",
"FStar.Sequence.Base.take_contains_equiv_exists_helper2",
"Pr... | [
"recursion"
] | false | false | true | false | false | let rec take_contains_equiv_exists_helper2
(ty: Type)
(s: list ty)
(n: nat{n <= length s})
(x: ty)
(i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x)) (ensures FLT.memP x (take s n)) =
| match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd . ()
and case_x_ne_hd . take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.drop_length_lemma | val drop_length_lemma: Prims.unit -> Lemma (drop_length_fact) | val drop_length_lemma: Prims.unit -> Lemma (drop_length_fact) | let drop_length_lemma () : Lemma (drop_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (drop s n) = length s - n
with
introduce _ ==> _
with given_antecedent. (
FLT.lemma_splitAt_snd_length n s
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 468,
"start_col": 8,
"start_line": 461
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 FStar.Sequence.Base.drop_length_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.op_Equality",
"Prims.int",
"FStar.Sequence.Base.drop",
"Prims.op_Subtraction",
"FStar.C... | [] | false | false | true | false | false | let drop_length_lemma () : Lemma (drop_length_fact) =
| introduce forall (ty: Type) (s: seq ty) (n: nat) . n <= length s ==>
length (drop s n) = length s - n
with introduce _ ==> _
with given_antecedent. (FLT.lemma_splitAt_snd_length n s) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.update_then_index_lemma | val update_then_index_lemma: Prims.unit -> Lemma (update_then_index_fact) | val update_then_index_lemma: Prims.unit -> Lemma (update_then_index_fact) | let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (u... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 257,
"start_col": 8,
"start_line": 246
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 FStar.Sequence.Base.update_then_index_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"FStar.Sequence.Base.update",
"Prims.l_imp",
"Prims.l_and",
"Prims.op_Equality",
"Prims.l_or",
"Prims.eq2",
"FStar... | [] | false | false | true | false | false | let update_then_index_lemma () : Lemma (update_then_index_fact) =
| update_maintains_length_lemma ();
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n:
nat{n < length (update s i v)}) . n < length s ==>
(i = n ==> index (update s i v) n == v) /\ (i <> n ==> index (update s i v) n == index s n)
with introduce _ ==> _
with given_antecedent. (update_then_index_hel... | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.take_length_lemma | val take_length_lemma: Prims.unit -> Lemma (take_length_fact) | val take_length_lemma: Prims.unit -> Lemma (take_length_fact) | let take_length_lemma () : Lemma (take_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (take s n) = n
with
introduce _ ==> _
with given_antecedent. (
lemma_splitAt_fst_length n s
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 441,
"start_col": 8,
"start_line": 434
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 FStar.Sequence.Base.take_length_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.op_Equality",
"FStar.Sequence.Base.take",
"FStar.Classical.Sugar.implies_intro",
"Prims.s... | [] | false | false | true | false | false | let take_length_lemma () : Lemma (take_length_fact) =
| introduce forall (ty: Type) (s: seq ty) (n: nat) . n <= length s ==> length (take s n) = n
with introduce _ ==> _
with given_antecedent. (lemma_splitAt_fst_length n s) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.drop_contains_equiv_exists_lemma | val drop_contains_equiv_exists_lemma: Prims.unit -> Lemma (drop_contains_equiv_exists_fact) | val drop_contains_equiv_exists_lemma: Prims.unit -> Lemma (drop_contains_equiv_exists_fact) | let drop_contains_equiv_exists_lemma () : Lemma (drop_contains_equiv_exists_fact) =
introduce
forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (drop s n) x <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with (
drop_contains_equiv_exis... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 412,
"start_col": 8,
"start_line": 403
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 FStar.Sequence.Base.drop_contains_equiv_exists_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.l_iff",
"FStar.Sequence.Base.contains",
"FStar.Sequence.Base.drop",
"Prims.l_Exists",
"Prims.l_and",
"... | [] | false | false | true | false | false | let drop_contains_equiv_exists_lemma () : Lemma (drop_contains_equiv_exists_fact) =
| introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty) . contains (drop s n) x <==>
(exists (i: nat). {:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with (drop_contains_equiv_exists_helper3 ty s n x;
assert (FLT.memP x (drop s n) <==> (exists (i: nat). n <= i /\ i < length s /\ index ... | false |
FStar.Matrix.fst | FStar.Matrix.matrix_left_mul_identity_aux_3 | val matrix_left_mul_identity_aux_3
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: under (m + 1) {k > i + 1})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> ... | val matrix_left_mul_identity_aux_3
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: under (m + 1) {k > i + 1})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> ... | let rec matrix_left_mul_identity_aux_3 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under(m+1){k>... | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 31,
"end_line": 1014,
"start_col": 0,
"start_line": 982
} | (*
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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_modu... | {
"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 |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq {FStar.Matrix.is_absorber (CM?.unit add) mul} ->
mx: FStar.Matrix.matrix c m m ->
i: FStar.IntegerIntervals.under m ->
j: FStar.IntegerIntervals.under m ->
k: FStar.IntegerIntervals.under (m + 1) {k > i +... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"FStar.IntegerIntervals.under",
"Prims.op_Addition",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.S... | [
"recursion"
] | false | false | true | false | false | let rec matrix_left_mul_identity_aux_3
#c
#eq
#m
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i: under m)
(j: under m)
(k: under (m + 1) {k > i + 1})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
... | let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
if (k - 1 = i + 1)
then matrix_left_mul_identity_aux_2 add mul mx i j (k - 1)
else matrix_left_mul_identity_aux... | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.index_into_build_lemma | val index_into_build_lemma: Prims.unit
-> Lemma (requires build_increments_length_fact u#a) (ensures index_into_build_fact u#a ()) | val index_into_build_lemma: Prims.unit
-> Lemma (requires build_increments_length_fact u#a) (ensures index_into_build_fact u#a ()) | let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> inde... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 182,
"start_col": 8,
"start_line": 174
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 (requires FStar.Sequence.Base.build_increments_length_fact)
(ensures FStar.Sequence.Base.index_into_build_fact ()) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"FStar.Sequence.Base.build",
"Prims.l_and",
"Prims.l_imp",
"Prims.op_Equality",
"Prims.eq2",
"FStar.Sequence.Base.in... | [] | false | false | true | false | false | let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a) (ensures index_into_build_fact u#a ()) =
| introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}) . (i = length s ==>
index (build s v) i == v) /\ (i <> length s ==> index (build s v) i == index s i)
with (index_into_build_helper u#a s v i) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.take_contains_equiv_exists_helper1 | val take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat). {:pattern index s i} i < n /\ i < length s /\ index s i == x)) | val take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat). {:pattern index s i} i < n /\ i < length s /\ index s i == x)) | let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
retu... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 15,
"end_line": 314,
"start_col": 8,
"start_line": 298
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 | ty: Type -> s: Prims.list ty -> n: Prims.nat{n <= FStar.Sequence.Base.length s} -> x: ty
-> FStar.Pervasives.Lemma (requires FStar.List.Tot.Base.memP x (FStar.Sequence.Base.take s n))
(ensures
exists (i: Prims.nat). {:pattern FStar.Sequence.Base.index s i}
i < n /\ i < FStar.Sequence.Base.leng... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"FStar.Classical.Sugar.or_elim",
"Prims.eq2",
"Prims.squash",
"Prims.l_not",
"Prims.l_Exists",
"Prims.l_and",
"Prims.op_LessThan",
"FStar.Sequence.Base.index",
"Prims._assert",
"FStar.Classi... | [
"recursion"
] | false | false | true | false | false | let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat). {:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
| match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat). {:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd . assert (index s 0 == x)
and case_x_ne_hd . (take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat).
i_tl < n - 1 ... | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.update_maintains_length_helper | val update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) | val update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) | let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 40,
"end_line": 224,
"start_col": 8,
"start_line": 218
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 | s: Prims.list ty -> i: Prims.nat{i < FStar.Sequence.Base.length s} -> v: ty
-> FStar.Pervasives.Lemma
(ensures
FStar.Sequence.Base.length (FStar.Sequence.Base.update s i v) = FStar.Sequence.Base.length s) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"FStar.List.Tot.Properties.append_length",
"FStar.Sequence.Base.append",
"Prims.Cons",
"Prims.Nil",
"Prims.unit",
"FStar.List.Tot.Base.lemma_splitAt_snd_length",
"FStar.Sequence.Base.lemma_splitAt_fst_le... | [] | false | false | true | false | false | let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
| let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.take_contains_equiv_exists_helper3 | val take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma
(FLT.memP x (take s n) <==>
(exists (i: nat). {:pattern index s i} i < n /\ i < length s /\ index s i == x)) | val take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma
(FLT.memP x (take s n) <==>
(exists (i: nat). {:pattern index s i} i < n /\ i < length s /\ index s i == x)) | let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (take s n) <==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (take s n) ==>
(exists (i: nat).{:pattern index s i} i < ... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 338,
"start_col": 8,
"start_line": 326
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 | ty: Type -> s: Prims.list ty -> n: Prims.nat{n <= FStar.Sequence.Base.length s} -> x: ty
-> FStar.Pervasives.Lemma
(ensures
FStar.List.Tot.Base.memP x (FStar.Sequence.Base.take s n) <==>
(exists (i: Prims.nat). {:pattern FStar.Sequence.Base.index s i}
i < n /\ i < FStar.Sequence.Base.length ... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"FStar.Classical.Sugar.implies_intro",
"Prims.l_Exists",
"Prims.l_and",
"Prims.op_LessThan",
"Prims.eq2",
"FStar.Sequence.Base.index",
"Prims.squash",
"FStar.List.Tot.Base.memP",
"FStar.Sequen... | [] | false | false | true | false | false | let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma
(FLT.memP x (take s n) <==>
(exists (i: nat). {:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
| introduce FLT.memP x (take s n) ==> (exists (i: nat). {:pattern index s i}
i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat). {:pattern index s i} i < n /\ i < length s /\ index s i == x) ==> FLT.memP
x
(take s n)
with given... | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.drop_contains_equiv_exists_helper2 | val drop_contains_equiv_exists_helper2
(ty: Type)
(s: list ty)
(n: nat{n <= length s})
(x: ty)
(i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x)) (ensures FLT.memP x (drop s n)) | val drop_contains_equiv_exists_helper2
(ty: Type)
(s: list ty)
(n: nat{n <= length s})
(x: ty)
(i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x)) (ensures FLT.memP x (drop s n)) | let rec drop_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x))
(ensures FLT.memP x (drop s n)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns FLT.memP x (drop s n)
... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 93,
"end_line": 386,
"start_col": 8,
"start_line": 373
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 |
ty: Type ->
s: Prims.list ty ->
n: Prims.nat{n <= FStar.Sequence.Base.length s} ->
x: ty ->
i: Prims.nat
-> FStar.Pervasives.Lemma
(requires n <= i /\ i < FStar.Sequence.Base.length s /\ FStar.Sequence.Base.index s i == x)
(ensures FStar.List.Tot.Base.memP x (FStar.Sequence.Base.drop ... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"FStar.Classical.Sugar.or_elim",
"Prims.eq2",
"Prims.int",
"Prims.squash",
"Prims.l_not",
"Prims.op_disEquality",
"FStar.List.Tot.Base.memP",
"FStar.Sequence.Base.drop",
"FStar.List.Tot.Proper... | [
"recursion"
] | false | false | true | false | false | let rec drop_contains_equiv_exists_helper2
(ty: Type)
(s: list ty)
(n: nat{n <= length s})
(x: ty)
(i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x)) (ensures FLT.memP x (drop s n)) =
| match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns FLT.memP x (drop s n)
with _ . FLT.lemma_index_memP s i
and _ . (drop_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1);
eliminate exists (i_tl: nat).
n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _.
i... | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.contains_iff_exists_index_lemma | val contains_iff_exists_index_lemma: Prims.unit -> Lemma (contains_iff_exists_index_fact) | val contains_iff_exists_index_lemma: Prims.unit -> Lemma (contains_iff_exists_index_fact) | let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 275,
"start_col": 8,
"start_line": 259
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 FStar.Sequence.Base.contains_iff_exists_index_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.l_iff",
"FStar.Sequence.Base.contains",
"Prims.l_Exists",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"Prims.eq2",
"FStar.Sequence.Base.in... | [] | false | false | true | false | false | let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
| introduce forall (ty: Type) (s: seq ty) (x: ty) . contains s x <==>
(exists (i: nat). {:pattern index s i} i < length s /\ index s i == x)
with (introduce contains s x ==> (exists (i: nat). {:pattern index s i}
i < length s /\ index s i == x)
with given_antecedent. (introduce exists (i: nat).i < length s /\ ind... | false |
FStar.Matrix.fst | FStar.Matrix.matrix_mul_is_associative | val matrix_mul_is_associative (#c:_) (#eq:_) (#m #n #p #q: pos) (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (mz: matrix c p q)
: Lemma ((matrix_equiv eq m q).eq ((matrix_mul add mul mx my) `matrix_mul add mul` mz)
... | val matrix_mul_is_associative (#c:_) (#eq:_) (#m #n #p #q: pos) (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (mz: matrix c p q)
: Lemma ((matrix_equiv eq m q).eq ((matrix_mul add mul mx my) `matrix_mul add mul` mz)
... | let matrix_mul_is_associative #c #eq #m #n #p #q (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (mz: matrix c p q)
: Lemma (matrix_eq_fun eq ((matrix_mul add mul mx my) `matrix_mul add mul` ... | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 46,
"end_line": 718,
"start_col": 0,
"start_line": 663
} | (*
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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"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 |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul:
FStar.Algebra.CommMonoid.Equiv.cm c eq
{FStar.Matrix.is_fully_distributive mul add /\ FStar.Matrix.is_absorber (CM?.unit add) mul} ->
mx: FStar.Matrix.matrix c m n ->
my: FStar.Matrix.matrix c n p ->
mz: FStar.Matrix.matrix c p q
-... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"Prims.l_and",
"FStar.Matrix.is_fully_distributive",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"FStar.Matrix.matrix_equiv_from_proof",
"FStar.... | [] | false | false | true | false | false | let matrix_mul_is_associative
#c
#eq
#m
#n
#p
#q
(add: CE.cm c eq)
(mul: CE.cm c eq {is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n)
(my: matrix c n p)
(mz: matrix c p q)
: Lemma
(matrix_eq_fun eq
(matrix_mu... | let rhs = matrix_mul add mul mx (matrix_mul add mul my mz) in
let lhs = matrix_mul add mul (matrix_mul add mul mx my) mz in
let mxy = matrix_mul add mul mx my in
let myz = matrix_mul add mul my mz in
let ( + ), ( * ), ( = ) = add.mult, mul.mult, eq.eq in
let aux i l : squash (ijth lhs i l = ijth rhs i l) =
let sum_j ... | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.extensionality_lemma | val extensionality_lemma: Prims.unit -> Lemma (extensionality_fact) | val extensionality_lemma: Prims.unit -> Lemma (extensionality_fact) | let extensionality_lemma () : Lemma (extensionality_fact) =
introduce forall (ty: Type) (a: seq ty) (b: seq ty). equal a b ==> a == b
with
introduce _ ==> _
with given_antecedent. (
introduce forall (i: nat) . i < length a ==> index a i == index b i
with
introduce _ ==> _
with gi... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 429,
"start_col": 8,
"start_line": 417
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 FStar.Sequence.Base.extensionality_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.l_imp",
"FStar.Sequence.Base.equal",
"Prims.eq2",
"FStar.Classical.Sugar.implies_intro",
"Prims.squash",
"FStar.List.Tot.Properties.index_extensionality",
"Prims.nat",
"Prims.b2t",
"Prims.... | [] | false | false | true | false | false | let extensionality_lemma () : Lemma (extensionality_fact) =
| introduce forall (ty: Type) (a: seq ty) (b: seq ty) . equal a b ==> a == b
with introduce _ ==> _
with given_antecedent. (introduce forall (i: nat) . i < length a ==> index a i == index b i
with introduce _ ==> _
with given_antecedent. (assert (index a i == index b i));
FStar.List.Tot.Properties.index_extensional... | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.drop_contains_equiv_exists_helper3 | val drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma
(FLT.memP x (drop s n) <==>
(exists (i: nat). {:pattern index s i} n <= i /\ i < length s /\ index s i == x)) | val drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma
(FLT.memP x (drop s n) <==>
(exists (i: nat). {:pattern index s i} n <= i /\ i < length s /\ index s i == x)) | let drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (drop s n) <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (drop s n) ==>
(exists (i: nat).{:pattern index s i} n <... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 401,
"start_col": 8,
"start_line": 388
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 | ty: Type -> s: Prims.list ty -> n: Prims.nat{n <= FStar.Sequence.Base.length s} -> x: ty
-> FStar.Pervasives.Lemma
(ensures
FStar.List.Tot.Base.memP x (FStar.Sequence.Base.drop s n) <==>
(exists (i: Prims.nat). {:pattern FStar.Sequence.Base.index s i}
n <= i /\ i < FStar.Sequence.Base.length... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"FStar.Classical.Sugar.implies_intro",
"Prims.l_Exists",
"Prims.l_and",
"Prims.op_LessThan",
"Prims.eq2",
"FStar.Sequence.Base.index",
"Prims.squash",
"FStar.List.Tot.Base.memP",
"FStar.Sequen... | [] | false | false | true | false | false | let drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma
(FLT.memP x (drop s n) <==>
(exists (i: nat). {:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
| introduce FLT.memP x (drop s n) ==> (exists (i: nat). {:pattern index s i}
n <= i /\ i < length s /\ index s i == x)
with given_antecedent. (drop_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat). {:pattern index s i} n <= i /\ i < length s /\ index s i == x) ==> FLT.memP
x
(drop s n)
with giv... | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.index_into_take_lemma | val index_into_take_lemma: Prims.unit
-> Lemma (requires take_length_fact u#a) (ensures index_into_take_fact u#a ()) | val index_into_take_lemma: Prims.unit
-> Lemma (requires take_length_fact u#a) (ensures index_into_take_fact u#a ()) | let index_into_take_lemma ()
: Lemma (requires take_length_fact u#a) (ensures index_into_take_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < n && n <= length s ==> index (take s n) j == index s j
with
introduce _ ==> _
with given_antecedent. (
assert (length... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 459,
"start_col": 8,
"start_line": 449
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 (requires FStar.Sequence.Base.take_length_fact)
(ensures FStar.Sequence.Base.index_into_take_fact ()) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.eq2",
"FStar.Sequence.Base.index",
"FStar.Seque... | [] | false | false | true | false | false | let index_into_take_lemma ()
: Lemma (requires take_length_fact u#a) (ensures index_into_take_fact u#a ()) =
| introduce forall (ty: Type) (s: seq ty) (n: nat) (j: nat) . j < n && n <= length s ==>
index (take s n) j == index s j
with introduce _ ==> _
with given_antecedent. (assert (length (take s n) == n);
index_into_take_helper s n j) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.index_into_build_helper | val index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) | val index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) | let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () e... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 64,
"end_line": 172,
"start_col": 8,
"start_line": 165
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 |
s: Prims.list ty ->
v: ty ->
i: Prims.nat{i < FStar.Sequence.Base.length (FStar.Sequence.Base.append s [v])}
-> FStar.Pervasives.Lemma (requires i <= FStar.Sequence.Base.length s)
(ensures
FStar.Sequence.Base.index (FStar.Sequence.Base.append s [v]) i ==
(match i = FStar.Sequence.Ba... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"FStar.Sequence.Base.append",
"Prims.Cons",
"Prims.Nil",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"FStar.Sequence.Base.index_into_build_helper",
"Prims.op_Subtraction",
"Prims.unit",
"FStar.... | [
"recursion"
] | false | false | true | false | false | let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
| FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl -> if i = 0 then () else index_into_build_helper tl v (i - 1) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.index_into_take_helper | val index_into_take_helper (#ty: Type) (s: list ty) (n j: nat)
: Lemma (requires j < n && n <= length s /\ length (take s n) = n)
(ensures index (take s n) j == index s j) | val index_into_take_helper (#ty: Type) (s: list ty) (n j: nat)
: Lemma (requires j < n && n <= length s /\ length (take s n) = n)
(ensures index (take s n) j == index s j) | let rec index_into_take_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < n && n <= length s /\ length (take s n) = n)
(ensures index (take s n) j == index s j) =
match s with
| hd :: tl -> if j = 0 || n = 0 then () else index_into_take_helper tl (n - 1) (j - 1) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 88,
"end_line": 447,
"start_col": 8,
"start_line": 443
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 | s: Prims.list ty -> n: Prims.nat -> j: Prims.nat
-> FStar.Pervasives.Lemma
(requires
j < n && n <= FStar.Sequence.Base.length s /\
FStar.Sequence.Base.length (FStar.Sequence.Base.take s n) = n)
(ensures
FStar.Sequence.Base.index (FStar.Sequence.Base.take s n) j == FStar.Sequence.Ba... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"Prims.op_BarBar",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"FStar.Sequence.Base.index_into_take_helper",
"Prims.op_Subtraction",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"FStar.Sequenc... | [
"recursion"
] | false | false | true | false | false | let rec index_into_take_helper (#ty: Type) (s: list ty) (n j: nat)
: Lemma (requires j < n && n <= length s /\ length (take s n) = n)
(ensures index (take s n) j == index s j) =
| match s with | hd :: tl -> if j = 0 || n = 0 then () else index_into_take_helper tl (n - 1) (j - 1) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.index_after_append_helper | val index_after_append_helper (ty: Type) (s0 s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures
index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) | val index_after_append_helper (ty: Type) (s0 s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures
index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) | let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 80,
"end_line": 198,
"start_col": 8,
"start_line": 193
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 | ty: Type -> s0: Prims.list ty -> s1: Prims.list ty -> n: Prims.nat
-> FStar.Pervasives.Lemma
(requires
n < FStar.Sequence.Base.length (FStar.Sequence.Base.append s0 s1) &&
FStar.Sequence.Base.length (FStar.Sequence.Base.append s0 s1) =
FStar.Sequence.Base.length s0 + FStar.Sequence.Base.... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"FStar.Sequence.Base.index_after_append_helper",
"Prims.op_Subtraction",
"Prims.unit",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"FStar.Sequence.Base.append",
"Prims.op_Addit... | [
"recursion"
] | false | false | true | false | false | let rec index_after_append_helper (ty: Type) (s0 s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures
index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
| match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.element_ranks_less_lemma | val element_ranks_less_lemma: Prims.unit -> Lemma (element_ranks_less_fact) | val element_ranks_less_lemma: Prims.unit -> Lemma (element_ranks_less_fact) | let element_ranks_less_lemma () : Lemma (element_ranks_less_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat). i < length s ==> rank (index s i) << rank s
with
introduce _ ==> _
with given_antecedent. (
contains_iff_exists_index_lemma ();
assert (contains s (index s i));
FLT.memP_pr... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 656,
"start_col": 8,
"start_line": 648
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 FStar.Sequence.Base.element_ranks_less_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"Prims.precedes",
"FStar.Sequence.Base.rank",
"FStar.Sequence.Base.index",
"FStar.Classical.Sugar.impli... | [] | false | false | true | false | false | let element_ranks_less_lemma () : Lemma (element_ranks_less_fact) =
| introduce forall (ty: Type) (s: seq ty) (i: nat) . i < length s ==> rank (index s i) << rank s
with introduce _ ==> _
with given_antecedent. (contains_iff_exists_index_lemma ();
assert (contains s (index s i));
FLT.memP_precedes (index s i) s) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.index_into_drop_lemma | val index_into_drop_lemma: Prims.unit
-> Lemma (requires drop_length_fact u#a) (ensures index_into_drop_fact u#a ()) | val index_into_drop_lemma: Prims.unit
-> Lemma (requires drop_length_fact u#a) (ensures index_into_drop_fact u#a ()) | let index_into_drop_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures index_into_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < length s - n ==> index (drop s n) j == index s (j + n)
with
introduce _ ==> _
with given_antecedent. (
assert (length... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 486,
"start_col": 8,
"start_line": 476
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 (requires FStar.Sequence.Base.drop_length_fact)
(ensures FStar.Sequence.Base.index_into_drop_fact ()) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Subtraction",
"FStar.Sequence.Base.length",
"Prims.eq2",
"FStar.Sequence.Base.index",
"FStar.Sequence.Base.drop",
"Prims.... | [] | false | false | true | false | false | let index_into_drop_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures index_into_drop_fact u#a ()) =
| introduce forall (ty: Type) (s: seq ty) (n: nat) (j: nat) . j < length s - n ==>
index (drop s n) j == index s (j + n)
with introduce _ ==> _
with given_antecedent. (assert (length (drop s n) = length s - n);
index_into_drop_helper s n j) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.append_then_take_or_drop_lemma | val append_then_take_or_drop_lemma: Prims.unit
-> Lemma (requires append_sums_lengths_fact u#a) (ensures append_then_take_or_drop_fact u#a ()) | val append_then_take_or_drop_lemma: Prims.unit
-> Lemma (requires append_sums_lengths_fact u#a) (ensures append_then_take_or_drop_fact u#a ()) | let append_then_take_or_drop_lemma ()
: Lemma (requires append_sums_lengths_fact u#a) (ensures append_then_take_or_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (t: seq ty) (n: nat).
n = length s ==> take (append s t) n == s /\ drop (append s t) n == t
with
introduce _ ==> _
with ... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 516,
"start_col": 8,
"start_line": 507
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 (requires FStar.Sequence.Base.append_sums_lengths_fact)
(ensures FStar.Sequence.Base.append_then_take_or_drop_fact ()) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_Equality",
"FStar.Sequence.Base.length",
"Prims.l_and",
"Prims.eq2",
"FStar.Sequence.Base.take",
"FStar.Sequence.Base.append",
"FStar.Sequence... | [] | false | false | true | false | false | let append_then_take_or_drop_lemma ()
: Lemma (requires append_sums_lengths_fact u#a) (ensures append_then_take_or_drop_fact u#a ()) =
| introduce forall (ty: Type) (s: seq ty) (t: seq ty) (n: nat) . n = length s ==>
take (append s t) n == s /\ drop (append s t) n == t
with introduce _ ==> _
with given_antecedent. (append_then_take_or_drop_helper s t n) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.drop_commutes_with_build_lemma | val drop_commutes_with_build_lemma: Prims.unit
-> Lemma (requires build_increments_length_fact u#a)
(ensures drop_commutes_with_build_fact u#a ()) | val drop_commutes_with_build_lemma: Prims.unit
-> Lemma (requires build_increments_length_fact u#a)
(ensures drop_commutes_with_build_fact u#a ()) | let drop_commutes_with_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures drop_commutes_with_build_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (n: nat).
n <= length s ==> drop (build s v) n == build (drop s n) v
with
introduce _ ==> _
with ... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 643,
"start_col": 8,
"start_line": 632
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 (requires FStar.Sequence.Base.build_increments_length_fact)
(ensures FStar.Sequence.Base.drop_commutes_with_build_fact ()) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.eq2",
"FStar.Sequence.Base.drop",
"FStar.Sequence.Base.build",
"FStar.Classical.Sugar.imp... | [] | false | false | true | false | false | let drop_commutes_with_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures drop_commutes_with_build_fact u#a ()) =
| introduce forall (ty: Type) (s: seq ty) (v: ty) (n: nat) . n <= length s ==>
drop (build s v) n == build (drop s n) v
with introduce _ ==> _
with given_antecedent. (assert (length (build s v) = 1 + length s);
drop_commutes_with_build_helper s v n) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_mul_congruence | val matrix_mul_congruence (#c:_) (#eq:_) (#m #n #p:pos) (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(mz: matrix c m n) (mw: matrix c n p)
: Lemma (requires (matrix_equiv eq m n).eq mx mz /\ (matrix_equiv eq n p).eq my mw)
(ensures (matri... | val matrix_mul_congruence (#c:_) (#eq:_) (#m #n #p:pos) (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(mz: matrix c m n) (mw: matrix c n p)
: Lemma (requires (matrix_equiv eq m n).eq mx mz /\ (matrix_equiv eq n p).eq my mw)
(ensures (matri... | let matrix_mul_congruence #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(mz: matrix c m n) (mw: matrix c n p)
: Lemma (requires matrix_eq_fun eq mx mz /\ matrix_eq_fun eq my mw)
(ensures matrix_eq_fun eq (matrix_mul add mul mx my) (mat... | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 89,
"end_line": 1103,
"start_col": 0,
"start_line": 1083
} | (*
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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"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 |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mx: FStar.Matrix.matrix c m n ->
my: FStar.Matrix.matrix c n p ->
mz: FStar.Matrix.matrix c m n ->
mw: FStar.Matrix.matrix c n p
-> FStar.Pervasives.Lemma
(requires
EQ?.eq (FStar.Matrix... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.matrix",
"FStar.Matrix.matrix_equiv_from_proof",
"FStar.Matrix.matrix_mul",
"FStar.IntegerIntervals.under",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.Algebra.CommMonoid.Equiv.__proj... | [] | false | false | true | false | false | let matrix_mul_congruence
#c
#eq
#m
#n
#p
(add: CE.cm c eq)
(mul: CE.cm c eq)
(mx: matrix c m n)
(my: matrix c n p)
(mz: matrix c m n)
(mw: matrix c n p)
: Lemma (requires matrix_eq_fun eq mx mz /\ matrix_eq_fun eq my mw)
(ensures matrix_eq_fun... | let aux (i: under m) (k: under p)
: Lemma ((ijth (matrix_mul add mul mx my) i k) `eq.eq` (ijth (matrix_mul add mul mz mw) i k)) =
let init_xy (j: under n) = mul.mult (ijth mx i j) (ijth my j k) in
let init_zw (j: under n) = mul.mult (ijth mz i j) (ijth mw j k) in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul... | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.drop_ignores_out_of_range_update_lemma | val drop_ignores_out_of_range_update_lemma: Prims.unit
-> Lemma (requires update_maintains_length_fact u#a)
(ensures drop_ignores_out_of_range_update_fact u#a ()) | val drop_ignores_out_of_range_update_lemma: Prims.unit
-> Lemma (requires update_maintains_length_fact u#a)
(ensures drop_ignores_out_of_range_update_fact u#a ()) | let drop_ignores_out_of_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a)
(ensures drop_ignores_out_of_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
i < n && n <= length s ==>
drop (update s i v) n == drop s n
with... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 620,
"start_col": 8,
"start_line": 608
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 (requires FStar.Sequence.Base.update_maintains_length_fact)
(ensures FStar.Sequence.Base.drop_ignores_out_of_range_update_fact ()) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.eq2",
"FStar.Sequence.Base.drop",
"FStar.Sequen... | [] | false | false | true | false | false | let drop_ignores_out_of_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a)
(ensures drop_ignores_out_of_range_update_fact u#a ()) =
| introduce forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat) . i < n && n <= length s ==>
drop (update s i v) n == drop s n
with introduce _ ==> _
with given_antecedent. (assert (length (update s i v) = length s);
drop_ignores_out_of_range_update_helper s i v n) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.update_then_index_helper | val update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) | val update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) | let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 56,
"end_line": 244,
"start_col": 8,
"start_line": 233
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 |
s: Prims.list ty ->
i: Prims.nat{i < FStar.Sequence.Base.length s} ->
v: ty ->
n: Prims.nat{n < FStar.Sequence.Base.length (FStar.Sequence.Base.update s i v)}
-> FStar.Pervasives.Lemma (requires n < FStar.Sequence.Base.length s)
(ensures
FStar.Sequence.Base.index (FStar.Sequence.Base.up... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"FStar.Sequence.Base.update",
"Prims.op_BarBar",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"FStar.Sequence.Base.update_then_index_helper",
"Prims.op_Subtraction",
"Prims.unit",
"Prims.squash",
... | [
"recursion"
] | false | false | true | false | false | let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
| match s with
| hd :: tl -> if i = 0 || n = 0 then () else update_then_index_helper tl (i - 1) v (n - 1) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_right_mul_identity_aux_2 | val matrix_right_mul_identity_aux_2
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: nat{k = j + 1})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth mx i... | val matrix_right_mul_identity_aux_2
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: nat{k = j + 1})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth mx i... | let matrix_right_mul_identity_aux_2 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=j+1}) ... | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 61,
"end_line": 857,
"start_col": 0,
"start_line": 828
} | (*
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... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.f... | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_modu... | {
"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 |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq {FStar.Matrix.is_absorber (CM?.unit add) mul} ->
mx: FStar.Matrix.matrix c m m ->
i: FStar.IntegerIntervals.under m ->
j: FStar.IntegerIntervals.under m ->
k: Prims.nat{k = j + 1}
-> FStar.Pervasives.Le... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"FStar.IntegerIntervals.under",
"Prims.nat",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Pri... | [] | false | false | true | false | false | let matrix_right_mul_identity_aux_2
#c
#eq
#m
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i: under m)
(j: under m)
(k: nat{k = j + 1})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k... | let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat, last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j j;
liat_equals_ini... | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.all_seq_facts_lemma | val all_seq_facts_lemma : unit -> Lemma (all_seq_facts u#a) | val all_seq_facts_lemma : unit -> Lemma (all_seq_facts u#a) | let all_seq_facts_lemma () : Lemma (all_seq_facts u#a) =
length_of_empty_is_zero_lemma u#a ();
length_zero_implies_empty_lemma u#a ();
singleton_length_one_lemma u#a ();
build_increments_length_lemma u#a ();
index_into_build_lemma u#a ();
append_sums_lengths_lemma u#a ();
index_into_singleton_lemma u#a ()... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 29,
"end_line": 752,
"start_col": 0,
"start_line": 715
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 FStar.Sequence.Base.all_seq_facts) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Sequence.Base.drop_then_drop_lemma",
"FStar.Sequence.Base.take_zero_lemma",
"FStar.Sequence.Base.drop_zero_lemma",
"FStar.Sequence.Base.append_take_drop_ranks_less_lemma",
"FStar.Sequence.Base.take_ranks_less_lemma",
"FStar.Sequence.Base.drop_ranks_less_lemma",
"FStar.Sequence.Bas... | [] | true | false | true | false | false | let all_seq_facts_lemma () : Lemma (all_seq_facts u#a) =
| length_of_empty_is_zero_lemma u#a ();
length_zero_implies_empty_lemma u#a ();
singleton_length_one_lemma u#a ();
build_increments_length_lemma u#a ();
index_into_build_lemma u#a ();
append_sums_lengths_lemma u#a ();
index_into_singleton_lemma u#a ();
index_after_append_lemma u#a ();
update_maintains_length_lemma u#a ()... | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.drop_ranks_less_lemma | val drop_ranks_less_lemma: Prims.unit -> Lemma (drop_ranks_less_fact) | val drop_ranks_less_lemma: Prims.unit -> Lemma (drop_ranks_less_fact) | let drop_ranks_less_lemma () : Lemma (drop_ranks_less_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat).
0 < i && i <= length s ==> rank (drop s i) << rank s
with
introduce _ ==> _
with given_antecedent. (
drop_ranks_less_helper ty s i
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 672,
"start_col": 8,
"start_line": 665
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 FStar.Sequence.Base.drop_ranks_less_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.precedes",
"FStar.Sequence.Base.rank",
"FStar.S... | [] | false | false | true | false | false | let drop_ranks_less_lemma () : Lemma (drop_ranks_less_fact) =
| introduce forall (ty: Type) (s: seq ty) (i: nat) . 0 < i && i <= length s ==>
rank (drop s i) << rank s
with introduce _ ==> _
with given_antecedent. (drop_ranks_less_helper ty s i) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.drop_commutes_with_in_range_update_lemma | val drop_commutes_with_in_range_update_lemma: Prims.unit
-> Lemma (requires update_maintains_length_fact u#a /\ drop_length_fact u#a)
(ensures drop_commutes_with_in_range_update_fact u#a ()) | val drop_commutes_with_in_range_update_lemma: Prims.unit
-> Lemma (requires update_maintains_length_fact u#a /\ drop_length_fact u#a)
(ensures drop_commutes_with_in_range_update_fact u#a ()) | let drop_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ drop_length_fact u#a)
(ensures drop_commutes_with_in_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
n <= i && i < length s ==>
drop (update... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 598,
"start_col": 8,
"start_line": 585
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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
(requires
FStar.Sequence.Base.update_maintains_length_fact /\ FStar.Sequence.Base.drop_length_fact)
(ensures FStar.Sequence.Base.drop_commutes_with_in_range_update_fact ()) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"Prims.eq2",
"FStar.Sequence.Base.drop",
"FStar.Sequen... | [] | false | false | true | false | false | let drop_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ drop_length_fact u#a)
(ensures drop_commutes_with_in_range_update_fact u#a ()) =
| introduce forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat) . n <= i && i < length s ==>
drop (update s i v) n == update (drop s n) (i - n) v
with introduce _ ==> _
with given_antecedent. (assert (length (update s i v) = length s);
assert (length (drop s n) = length s - n);
drop_commutes_with_in_range_update_... | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.drop_index_offset_lemma | val drop_index_offset_lemma: Prims.unit
-> Lemma (requires drop_length_fact u#a) (ensures drop_index_offset_fact u#a ()) | val drop_index_offset_lemma: Prims.unit
-> Lemma (requires drop_length_fact u#a) (ensures drop_index_offset_fact u#a ()) | let drop_index_offset_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures drop_index_offset_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (k: nat).
n <= k && k < length s ==> index (drop s n) (k - n) == index s k
with
introduce _ ==> _
with given_antecedent. (
asse... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 498,
"start_col": 8,
"start_line": 488
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 (requires FStar.Sequence.Base.drop_length_fact)
(ensures FStar.Sequence.Base.drop_index_offset_fact ()) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"Prims.eq2",
"FStar.Sequence.Base.index",
"FStar.Seque... | [] | false | false | true | false | false | let drop_index_offset_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures drop_index_offset_fact u#a ()) =
| introduce forall (ty: Type) (s: seq ty) (n: nat) (k: nat) . n <= k && k < length s ==>
index (drop s n) (k - n) == index s k
with introduce _ ==> _
with given_antecedent. (assert (length (drop s n) = length s - n);
index_into_drop_helper s n (k - n)) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.append_then_take_or_drop_helper | val append_then_take_or_drop_helper (#ty: Type) (s t: list ty) (n: nat)
: Lemma (requires n = length s /\ length (append s t) = length s + length t)
(ensures take (append s t) n == s /\ drop (append s t) n == t) | val append_then_take_or_drop_helper (#ty: Type) (s t: list ty) (n: nat)
: Lemma (requires n = length s /\ length (append s t) = length s + length t)
(ensures take (append s t) n == s /\ drop (append s t) n == t) | let rec append_then_take_or_drop_helper (#ty: Type) (s: list ty) (t: list ty) (n: nat)
: Lemma (requires n = length s /\ length (append s t) = length s + length t)
(ensures take (append s t) n == s /\ drop (append s t) n == t) =
match s with
| [] -> ()
| hd :: tl -> append_then_take_or_drop_helper tl... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 60,
"end_line": 505,
"start_col": 8,
"start_line": 500
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 | s: Prims.list ty -> t: Prims.list ty -> n: Prims.nat
-> FStar.Pervasives.Lemma
(requires
n = FStar.Sequence.Base.length s /\
FStar.Sequence.Base.length (FStar.Sequence.Base.append s t) =
FStar.Sequence.Base.length s + FStar.Sequence.Base.length t)
(ensures
FStar.Sequence.Ba... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"FStar.Sequence.Base.append_then_take_or_drop_helper",
"Prims.op_Subtraction",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Prims.op_Equality",
"FStar.Sequence.Base.length",
"Prims.int",
"FStar.Sequence.Base.append",
"Prims.op_Addition",
"Prims.squash",
"Prims.eq2"... | [
"recursion"
] | false | false | true | false | false | let rec append_then_take_or_drop_helper (#ty: Type) (s t: list ty) (n: nat)
: Lemma (requires n = length s /\ length (append s t) = length s + length t)
(ensures take (append s t) n == s /\ drop (append s t) n == t) =
| match s with
| [] -> ()
| hd :: tl -> append_then_take_or_drop_helper tl t (n - 1) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.drop_commutes_with_build_helper | val drop_commutes_with_build_helper (#ty: Type) (s: list ty) (v: ty) (n: nat)
: Lemma (requires n <= length s /\ length (append s [v]) = 1 + length s)
(ensures drop (append s [v]) n == append (drop s n) [v]) | val drop_commutes_with_build_helper (#ty: Type) (s: list ty) (v: ty) (n: nat)
: Lemma (requires n <= length s /\ length (append s [v]) = 1 + length s)
(ensures drop (append s [v]) n == append (drop s n) [v]) | let rec drop_commutes_with_build_helper (#ty: Type) (s: list ty) (v: ty) (n: nat)
: Lemma (requires n <= length s /\ length (append s [v]) = 1 + length s)
(ensures drop (append s [v]) n == append (drop s n) [v]) =
match s with
| [] ->
assert (append s [v] == [v]);
assert (n == 0);
()
| h... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 82,
"end_line": 630,
"start_col": 8,
"start_line": 622
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 | s: Prims.list ty -> v: ty -> n: Prims.nat
-> FStar.Pervasives.Lemma
(requires
n <= FStar.Sequence.Base.length s /\
FStar.Sequence.Base.length (FStar.Sequence.Base.append s [v]) =
1 + FStar.Sequence.Base.length s)
(ensures
FStar.Sequence.Base.drop (FStar.Sequence.Base.append... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"FStar.Sequence.Base.append",
"Prims.Cons",
"Prims.Nil",
"Prims.op_Equality",
"Prims.bool",
"FStar.Sequence.Base.drop_commutes_with_build_helper",
"Prims.op_Subtraction",
"Prims.l_and",
"Prims.b2t",
"Pr... | [
"recursion"
] | false | false | true | false | false | let rec drop_commutes_with_build_helper (#ty: Type) (s: list ty) (v: ty) (n: nat)
: Lemma (requires n <= length s /\ length (append s [v]) = 1 + length s)
(ensures drop (append s [v]) n == append (drop s n) [v]) =
| match s with
| [] ->
assert (append s [v] == [v]);
assert (n == 0);
()
| hd :: tl -> if n = 0 then () else drop_commutes_with_build_helper tl v (n - 1) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.take_ignores_out_of_range_update_lemma | val take_ignores_out_of_range_update_lemma: Prims.unit
-> Lemma (requires update_maintains_length_fact u#a)
(ensures take_ignores_out_of_range_update_fact u#a ()) | val take_ignores_out_of_range_update_lemma: Prims.unit
-> Lemma (requires update_maintains_length_fact u#a)
(ensures take_ignores_out_of_range_update_fact u#a ()) | let take_ignores_out_of_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a)
(ensures take_ignores_out_of_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
n <= i && i < length s ==>
take (update s i v) n == take s n
with... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 564,
"start_col": 8,
"start_line": 552
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 (requires FStar.Sequence.Base.update_maintains_length_fact)
(ensures FStar.Sequence.Base.take_ignores_out_of_range_update_fact ()) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"Prims.eq2",
"FStar.Sequence.Base.take",
"FStar.Sequen... | [] | false | false | true | false | false | let take_ignores_out_of_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a)
(ensures take_ignores_out_of_range_update_fact u#a ()) =
| introduce forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat) . n <= i && i < length s ==>
take (update s i v) n == take s n
with introduce _ ==> _
with given_antecedent. (assert (length (update s i v) = length s);
take_ignores_out_of_range_update_helper s i v n) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.append_take_drop_ranks_less_lemma | val append_take_drop_ranks_less_lemma: Prims.unit -> Lemma (append_take_drop_ranks_less_fact) | val append_take_drop_ranks_less_lemma: Prims.unit -> Lemma (append_take_drop_ranks_less_fact) | let append_take_drop_ranks_less_lemma () : Lemma (append_take_drop_ranks_less_fact) =
take_length_lemma ();
drop_length_lemma ();
append_sums_lengths_lemma () | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 30,
"end_line": 680,
"start_col": 8,
"start_line": 677
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 FStar.Sequence.Base.append_take_drop_ranks_less_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Sequence.Base.append_sums_lengths_lemma",
"FStar.Sequence.Base.drop_length_lemma",
"FStar.Sequence.Base.take_length_lemma",
"Prims.l_True",
"Prims.squash",
"FStar.Sequence.Base.append_take_drop_ranks_less_fact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let append_take_drop_ranks_less_lemma () : Lemma (append_take_drop_ranks_less_fact) =
| take_length_lemma ();
drop_length_lemma ();
append_sums_lengths_lemma () | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.take_ranks_less_lemma | val take_ranks_less_lemma: Prims.unit -> Lemma (take_ranks_less_fact) | val take_ranks_less_lemma: Prims.unit -> Lemma (take_ranks_less_fact) | let take_ranks_less_lemma () : Lemma (take_ranks_less_fact) =
take_length_lemma () | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 22,
"end_line": 675,
"start_col": 8,
"start_line": 674
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 FStar.Sequence.Base.take_ranks_less_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Sequence.Base.take_length_lemma",
"Prims.l_True",
"Prims.squash",
"FStar.Sequence.Base.take_ranks_less_fact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let take_ranks_less_lemma () : Lemma (take_ranks_less_fact) =
| take_length_lemma () | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.drop_ranks_less_helper | val drop_ranks_less_helper (ty: Type) (s: list ty) (i: nat)
: Lemma (requires 0 < i && i <= length s) (ensures drop s i << s) | val drop_ranks_less_helper (ty: Type) (s: list ty) (i: nat)
: Lemma (requires 0 < i && i <= length s) (ensures drop s i << s) | let rec drop_ranks_less_helper (ty: Type) (s: list ty) (i: nat)
: Lemma (requires 0 < i && i <= length s)
(ensures drop s i << s) =
match s with
| [] -> ()
| hd :: tl -> if i = 1 then () else drop_ranks_less_helper ty tl (i - 1) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 74,
"end_line": 663,
"start_col": 8,
"start_line": 658
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 | ty: Type -> s: Prims.list ty -> i: Prims.nat
-> FStar.Pervasives.Lemma (requires 0 < i && i <= FStar.Sequence.Base.length s)
(ensures FStar.Sequence.Base.drop s i << s) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"FStar.Sequence.Base.drop_ranks_less_helper",
"Prims.op_Subtraction",
"Prims.unit",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.squash",
"P... | [
"recursion"
] | false | false | true | false | false | let rec drop_ranks_less_helper (ty: Type) (s: list ty) (i: nat)
: Lemma (requires 0 < i && i <= length s) (ensures drop s i << s) =
| match s with
| [] -> ()
| hd :: tl -> if i = 1 then () else drop_ranks_less_helper ty tl (i - 1) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.take_commutes_with_in_range_update_lemma | val take_commutes_with_in_range_update_lemma: Prims.unit
-> Lemma (requires update_maintains_length_fact u#a /\ take_length_fact u#a)
(ensures take_commutes_with_in_range_update_fact u#a ()) | val take_commutes_with_in_range_update_lemma: Prims.unit
-> Lemma (requires update_maintains_length_fact u#a /\ take_length_fact u#a)
(ensures take_commutes_with_in_range_update_fact u#a ()) | let take_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ take_length_fact u#a)
(ensures take_commutes_with_in_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
i < n && n <= length s ==>
take (update... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 542,
"start_col": 8,
"start_line": 529
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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
(requires
FStar.Sequence.Base.update_maintains_length_fact /\ FStar.Sequence.Base.take_length_fact)
(ensures FStar.Sequence.Base.take_commutes_with_in_range_update_fact ()) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.eq2",
"FStar.Sequence.Base.take",
"FStar.Sequen... | [] | false | false | true | false | false | let take_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ take_length_fact u#a)
(ensures take_commutes_with_in_range_update_fact u#a ()) =
| introduce forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat) . i < n && n <= length s ==>
take (update s i v) n == update (take s n) i v
with introduce _ ==> _
with given_antecedent. (assert (length (update s i v) = length s);
assert (length (take s n) = n);
take_commutes_with_in_range_update_helper s i v n) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.take_ignores_out_of_range_update_helper | val take_ignores_out_of_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i /\ i < length s /\ length (update s i v) = length s)
(ensures take (update s i v) n == take s n) | val take_ignores_out_of_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i /\ i < length s /\ length (update s i v) = length s)
(ensures take (update s i v) n == take s n) | let rec take_ignores_out_of_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i
/\ i < length s
/\ length (update s i v) = length s)
(ensures take (update s i v) n == take s n) =
match s with
| hd :: tl -> if n = 0 th... | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 98,
"end_line": 550,
"start_col": 8,
"start_line": 544
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 th... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "F... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"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 | s: Prims.list ty -> i: Prims.nat -> v: ty -> n: Prims.nat
-> FStar.Pervasives.Lemma
(requires
n <= i /\ i < FStar.Sequence.Base.length s /\
FStar.Sequence.Base.length (FStar.Sequence.Base.update s i v) = FStar.Sequence.Base.length s
)
(ensures
FStar.Sequence.Base.take (FStar.... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"FStar.Sequence.Base.take_ignores_out_of_range_update_helper",
"Prims.op_Subtraction",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"FStar.... | [
"recursion"
] | false | false | true | false | false | let rec take_ignores_out_of_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i /\ i < length s /\ length (update s i v) = length s)
(ensures take (update s i v) n == take s n) =
| match s with
| hd :: tl -> if n = 0 then () else take_ignores_out_of_range_update_helper tl (i - 1) v (n - 1) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.