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
sequencelengths 0
2
| mutual_with
sequencelengths 0
11
| ideal_premises
sequencelengths 0
236
| proof_features
sequencelengths 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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
DependentBoolRefinement.fst | DependentBoolRefinement.src_env | val src_env : Type0 | let src_env = list (var & binding) | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 34,
"end_line": 148,
"start_col": 0,
"start_line": 148
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"DependentBoolRefinement.var",
"DependentBoolRefinement.binding"
] | [] | false | false | false | true | true | let src_env =
| list (var & binding) | false |
|
DependentBoolRefinement.fst | DependentBoolRefinement.lookup_ty | val lookup_ty (e: src_env) (x: var) : option src_ty | val lookup_ty (e: src_env) (x: var) : option src_ty | let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 15,
"end_line": 166,
"start_col": 0,
"start_line": 162
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | e: DependentBoolRefinement.src_env -> x: DependentBoolRefinement.var
-> FStar.Pervasives.Native.option DependentBoolRefinement.src_ty | Prims.Tot | [
"total"
] | [] | [
"DependentBoolRefinement.src_env",
"DependentBoolRefinement.var",
"DependentBoolRefinement.lookup",
"DependentBoolRefinement.binding",
"DependentBoolRefinement.src_ty",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.None"
] | [] | false | false | false | true | false | let lookup_ty (e: src_env) (x: var) : option src_ty =
| match lookup e x with
| Some (Inl t) -> Some t
| _ -> None | false |
DependentBoolRefinement.fst | DependentBoolRefinement.b2t_ty | val b2t_ty:R.term | val b2t_ty:R.term | let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero)))) | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 133,
"end_line": 214,
"start_col": 0,
"start_line": 214
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"] | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | FStar.Stubs.Reflection.Types.term | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.V2.Builtins.pack_ln",
"FStar.Stubs.Reflection.V2.Data.Tv_Arrow",
"FStar.Reflection.Typing.mk_simple_binder",
"FStar.Reflection.Typing.pp_name_default",
"FStar.Reflection.Typing.bool_ty",
"FStar.Reflection.Typing.mk_total",
"FStar.Reflection.Typing.tm_type",
"FStar.Reflection.Typing.u_zero"
] | [] | false | false | false | true | false | let b2t_ty:R.term =
| let open R in
pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty)
(RT.mk_total (RT.tm_type RT.u_zero))) | false |
DependentBoolRefinement.fst | DependentBoolRefinement.b2t_lid | val b2t_lid:R.name | val b2t_lid:R.name | let b2t_lid : R.name = ["Prims"; "b2t"] | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 39,
"end_line": 212,
"start_col": 0,
"start_line": 212
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | FStar.Stubs.Reflection.Types.name | Prims.Tot | [
"total"
] | [] | [
"Prims.Cons",
"Prims.string",
"Prims.Nil"
] | [] | false | false | false | true | false | let b2t_lid:R.name =
| ["Prims"; "b2t"] | false |
DependentBoolRefinement.fst | DependentBoolRefinement.max | val max : n1: Prims.nat -> n2: Prims.nat -> Prims.nat | let max (n1 n2:nat) = if n1 < n2 then n2 else n1 | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 48,
"end_line": 168,
"start_col": 0,
"start_line": 168
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | n1: Prims.nat -> n2: Prims.nat -> Prims.nat | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Prims.op_LessThan",
"Prims.bool"
] | [] | false | false | false | true | false | let max (n1 n2: nat) =
| if n1 < n2 then n2 else n1 | false |
|
DependentBoolRefinement.fst | DependentBoolRefinement.b2t_fv | val b2t_fv:R.fv | val b2t_fv:R.fv | let b2t_fv : R.fv = R.pack_fv b2t_lid | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 37,
"end_line": 213,
"start_col": 0,
"start_line": 213
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | FStar.Stubs.Reflection.Types.fv | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.V2.Builtins.pack_fv",
"DependentBoolRefinement.b2t_lid"
] | [] | false | false | false | true | false | let b2t_fv:R.fv =
| R.pack_fv b2t_lid | false |
DependentBoolRefinement.fst | DependentBoolRefinement.r_b2t | val r_b2t (t: R.term) : R.term | val r_b2t (t: R.term) : R.term | let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit))) | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 67,
"end_line": 217,
"start_col": 0,
"start_line": 215
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | t: FStar.Stubs.Reflection.Types.term -> FStar.Stubs.Reflection.Types.term | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.term",
"FStar.Stubs.Reflection.V2.Builtins.pack_ln",
"FStar.Stubs.Reflection.V2.Data.Tv_App",
"FStar.Stubs.Reflection.V2.Data.Tv_FVar",
"DependentBoolRefinement.b2t_fv",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Stubs.Reflection.V2.Data.aqualv",
"FStar.Stubs.Reflection.V2.Data.Q_Explicit"
] | [] | false | false | false | true | false | let r_b2t (t: R.term) : R.term =
| let open R in pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)) | false |
DependentBoolRefinement.fst | DependentBoolRefinement.fstar_top_env | val fstar_top_env : Type0 | let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
} | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 333,
"start_col": 0,
"start_line": 330
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
} | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"DependentBoolRefinement.fstar_env",
"Prims.l_Forall",
"Prims.int",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_None",
"FStar.Stubs.Reflection.Types.term",
"FStar.Reflection.Typing.lookup_bvar"
] | [] | false | false | false | true | true | let fstar_top_env =
| g: fstar_env{forall x. None? (RT.lookup_bvar g x)} | false |
|
DependentBoolRefinement.fst | DependentBoolRefinement.fstar_env | val fstar_env : Type0 | let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
} | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 328,
"start_col": 0,
"start_line": 324
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.env",
"Prims.l_and",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.Stubs.Reflection.Types.term",
"FStar.Reflection.Typing.lookup_fvar",
"FStar.Reflection.Typing.bool_fv",
"FStar.Pervasives.Native.Some",
"FStar.Reflection.Typing.tm_type",
"FStar.Reflection.Typing.u_zero",
"DependentBoolRefinement.b2t_fv",
"DependentBoolRefinement.b2t_ty"
] | [] | false | false | false | true | true | let fstar_env =
| g:
R.env
{ RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty } | false |
|
DependentBoolRefinement.fst | DependentBoolRefinement.elab_eqn | val elab_eqn (e1 e2: src_exp) : R.term | val elab_eqn (e1 e2: src_exp) : R.term | let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2) | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 59,
"end_line": 310,
"start_col": 0,
"start_line": 308
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | e1: DependentBoolRefinement.src_exp -> e2: DependentBoolRefinement.src_exp
-> FStar.Stubs.Reflection.Types.term | Prims.Tot | [
"total"
] | [] | [
"DependentBoolRefinement.src_exp",
"FStar.Reflection.Typing.eq2",
"FStar.Reflection.Typing.u_zero",
"FStar.Reflection.Typing.bool_ty",
"DependentBoolRefinement.elab_exp",
"FStar.Stubs.Reflection.Types.term"
] | [] | false | false | false | true | false | let elab_eqn (e1 e2: src_exp) : R.term =
| RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2) | false |
DependentBoolRefinement.fst | DependentBoolRefinement.extend_env_l | val extend_env_l : g: FStar.Stubs.Reflection.Types.env -> sg: DependentBoolRefinement.src_env
-> FStar.Stubs.Reflection.Types.env | let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 6,
"end_line": 322,
"start_col": 0,
"start_line": 318
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | g: FStar.Stubs.Reflection.Types.env -> sg: DependentBoolRefinement.src_env
-> FStar.Stubs.Reflection.Types.env | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.env",
"DependentBoolRefinement.src_env",
"FStar.List.Tot.Base.fold_right",
"FStar.Pervasives.Native.tuple2",
"FStar.Stubs.Reflection.V2.Data.var",
"DependentBoolRefinement.binding",
"FStar.Reflection.Typing.extend_env",
"DependentBoolRefinement.elab_binding"
] | [] | false | false | false | true | false | let extend_env_l (g: R.env) (sg: src_env) =
| L.fold_right (fun (x, b) g -> RT.extend_env g x (elab_binding b)) sg g | false |
|
DependentBoolRefinement.fst | DependentBoolRefinement.s_height | val s_height (#f #g #t0 #t1: _) (d: sub_typing f g t0 t1) : GTot nat | val s_height (#f #g #t0 #t1: _) (d: sub_typing f g t0 t1) : GTot nat | let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1 | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 416,
"start_col": 0,
"start_line": 414
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | d: DependentBoolRefinement.sub_typing f g t0 t1 -> Prims.GTot Prims.nat | Prims.GTot | [
"sometrivial"
] | [] | [
"DependentBoolRefinement.fstar_top_env",
"DependentBoolRefinement.src_env",
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.sub_typing",
"Prims.nat"
] | [] | false | false | false | false | false | let s_height #f #g #t0 #t1 (d: sub_typing f g t0 t1) : GTot nat =
| 1 | false |
DependentBoolRefinement.fst | DependentBoolRefinement.open_ty' | val open_ty' (t: src_ty) (v: src_exp) (n: index) : Tot src_ty (decreases t) | val open_ty' (t: src_ty) (v: src_exp) (n: index) : Tot src_ty (decreases t) | let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1)) | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 70,
"end_line": 79,
"start_col": 0,
"start_line": 62
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
t: DependentBoolRefinement.src_ty ->
v: DependentBoolRefinement.src_exp ->
n: DependentBoolRefinement.index
-> Prims.Tot DependentBoolRefinement.src_ty | Prims.Tot | [
"total",
""
] | [
"open_exp'",
"open_ty'"
] | [
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.index",
"DependentBoolRefinement.TBool",
"DependentBoolRefinement.TRefineBool",
"DependentBoolRefinement.open_exp'",
"Prims.op_Addition",
"DependentBoolRefinement.TArrow",
"DependentBoolRefinement.open_ty'"
] | [
"mutual recursion"
] | false | false | false | true | false | let rec open_ty' (t: src_ty) (v: src_exp) (n: index) : Tot src_ty (decreases t) =
| match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1)) | false |
DependentBoolRefinement.fst | DependentBoolRefinement.close_exp' | val close_exp' (e: src_exp) (v: var) (n: nat) : Tot src_exp (decreases e) | val close_exp' (e: src_exp) (v: var) (n: nat) : Tot src_exp (decreases e) | let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1)) | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 72,
"end_line": 98,
"start_col": 0,
"start_line": 81
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | e: DependentBoolRefinement.src_exp -> v: DependentBoolRefinement.var -> n: Prims.nat
-> Prims.Tot DependentBoolRefinement.src_exp | Prims.Tot | [
"total",
""
] | [
"close_exp'",
"close_ty'"
] | [
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.var",
"Prims.nat",
"Prims.bool",
"Prims.op_Equality",
"DependentBoolRefinement.EBVar",
"DependentBoolRefinement.EVar",
"DependentBoolRefinement.index",
"DependentBoolRefinement.EIf",
"DependentBoolRefinement.close_exp'",
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.ELam",
"DependentBoolRefinement.close_ty'",
"Prims.op_Addition",
"DependentBoolRefinement.EApp"
] | [
"mutual recursion"
] | false | false | false | true | false | let rec close_exp' (e: src_exp) (v: var) (n: nat) : Tot src_exp (decreases e) =
| match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n) | false |
DependentBoolRefinement.fst | DependentBoolRefinement.ln' | val ln' (e: src_exp) (n: int) : bool | val ln' (e: src_exp) (n: int) : bool | let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 54,
"end_line": 57,
"start_col": 0,
"start_line": 42
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | e: DependentBoolRefinement.src_exp -> n: Prims.int -> Prims.bool | Prims.Tot | [
"total"
] | [
"ln'",
"ln_ty'"
] | [
"DependentBoolRefinement.src_exp",
"Prims.int",
"Prims.bool",
"DependentBoolRefinement.var",
"DependentBoolRefinement.index",
"Prims.op_LessThanOrEqual",
"Prims.op_AmpAmp",
"DependentBoolRefinement.ln'",
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.ln_ty'",
"Prims.op_Addition"
] | [
"mutual recursion"
] | false | false | false | true | false | let rec ln' (e: src_exp) (n: int) : bool =
| match e with
| EBool _ | EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n | false |
DependentBoolRefinement.fst | DependentBoolRefinement.freevars_ty | val freevars_ty (t: src_ty) : Set.set var | val freevars_ty (t: src_ty) : Set.set var | let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 33,
"end_line": 40,
"start_col": 0,
"start_line": 26
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | t: DependentBoolRefinement.src_ty -> FStar.Set.set DependentBoolRefinement.var | Prims.Tot | [
"total"
] | [
"freevars",
"freevars_ty"
] | [
"DependentBoolRefinement.src_ty",
"FStar.Set.empty",
"DependentBoolRefinement.var",
"FStar.Set.union",
"DependentBoolRefinement.freevars_ty",
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.freevars",
"FStar.Set.set"
] | [
"mutual recursion"
] | false | false | false | true | false | let rec freevars_ty (t: src_ty) : Set.set var =
| match t with
| TBool -> Set.empty
| TArrow t1 t2 -> (freevars_ty t1) `Set.union` (freevars_ty t2)
| TRefineBool e -> freevars e | false |
DependentBoolRefinement.fst | DependentBoolRefinement.ln_ty' | val ln_ty' (t: src_ty) (n: int) : bool | val ln_ty' (t: src_ty) (n: int) : bool | let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 54,
"end_line": 57,
"start_col": 0,
"start_line": 42
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | t: DependentBoolRefinement.src_ty -> n: Prims.int -> Prims.bool | Prims.Tot | [
"total"
] | [
"ln'",
"ln_ty'"
] | [
"DependentBoolRefinement.src_ty",
"Prims.int",
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.ln'",
"Prims.op_Addition",
"Prims.op_AmpAmp",
"DependentBoolRefinement.ln_ty'",
"Prims.bool"
] | [
"mutual recursion"
] | false | false | false | true | false | let rec ln_ty' (t: src_ty) (n: int) : bool =
| match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) | false |
Hacl.Impl.Blake2.Generic.fst | Hacl.Impl.Blake2.Generic.serialize_params_blake2s | val serialize_params_blake2s
(kk: size_t{v kk <= Spec.max_key Spec.Blake2S})
(nn: size_t{1 <= v nn /\ v nn <= Spec.max_output Spec.Blake2S})
(p: blake2_params Spec.Blake2S)
(b: lbuffer (word_t Spec.Blake2S) 8ul)
: Stack unit
(requires
fun h ->
live h b /\ blake2_params_inv h p /\
LowStar.Buffer.loc_disjoint (loc b) (blake2_params_loc p) /\
as_seq h b == Seq.create 8 (u32 0))
(ensures
fun h0 _ h1 ->
modifies (loc b) h0 h1 /\
as_seq h1 b ==
Spec.serialize_blake2_params (Spec.set_key_length (Spec.set_digest_length (blake2_params_v
h0
p)
(v nn))
(v kk))) | val serialize_params_blake2s
(kk: size_t{v kk <= Spec.max_key Spec.Blake2S})
(nn: size_t{1 <= v nn /\ v nn <= Spec.max_output Spec.Blake2S})
(p: blake2_params Spec.Blake2S)
(b: lbuffer (word_t Spec.Blake2S) 8ul)
: Stack unit
(requires
fun h ->
live h b /\ blake2_params_inv h p /\
LowStar.Buffer.loc_disjoint (loc b) (blake2_params_loc p) /\
as_seq h b == Seq.create 8 (u32 0))
(ensures
fun h0 _ h1 ->
modifies (loc b) h0 h1 /\
as_seq h1 b ==
Spec.serialize_blake2_params (Spec.set_key_length (Spec.set_digest_length (blake2_params_v
h0
p)
(v nn))
(v kk))) | let serialize_params_blake2s
(kk:size_t{v kk <= Spec.max_key Spec.Blake2S})
(nn: size_t{1 <= v nn /\ v nn <= Spec.max_output Spec.Blake2S})
(p: blake2_params Spec.Blake2S)
(b: lbuffer (word_t Spec.Blake2S) 8ul)
: Stack unit
(requires fun h -> live h b /\
blake2_params_inv h p /\
LowStar.Buffer.loc_disjoint (loc b) (blake2_params_loc p) /\
as_seq h b == Seq.create 8 (u32 0)
)
(ensures fun h0 _ h1 ->
modifies (loc b) h0 h1 /\
as_seq h1 b == Spec.serialize_blake2_params
(Spec.set_key_length (Spec.set_digest_length (blake2_params_v h0 p) (v nn)) (v kk)))
= let h0 = ST.get () in
[@inline_let]
let kk_shift_8 = shift_left (to_u32 kk) (size 8) in
[@inline_let]
let fanout_shift_16 = shift_left (to_u32 p.fanout) (size 16) in
[@inline_let]
let depth_shift_24 = shift_left (to_u32 p.depth) (size 24) in
[@inline_let]
let v0 = (to_u32 nn) ^. kk_shift_8 ^. fanout_shift_16 ^. depth_shift_24 in
[@inline_let]
let v1 = p.leaf_length in
[@inline_let]
let v2 = p.node_offset in
[@inline_let]
let node_depth_shift_16 = shift_left (to_u32 p.node_depth) (size 16) in
[@inline_let]
let inner_length_shift_16 = shift_left (to_u32 p.inner_length) (size 24) in
[@inline_let]
let v3 = (to_u32 p.xof_length) ^. node_depth_shift_16 ^. inner_length_shift_16 in
uints_from_bytes_le (sub b 4ul 2ul) p.salt;
uints_from_bytes_le (sub b 6ul 2ul) p.personal;
// AF: Putting these writes *after* modifications on a subbuffer of b helps with modifies-reasoning:
// By putting them before, F* struggles with proving that b[0..3] is not modified by uints_from_bytes_le
b.(0ul) <- v0;
b.(1ul) <- v1;
b.(2ul) <- v2;
b.(3ul) <- v3;
let h1 = ST.get () in
let aux () : Lemma (as_seq h1 b `Seq.equal` Spec.serialize_blake2s_params
(Spec.set_key_length (Spec.set_digest_length (blake2_params_v h0 p) (v nn)) (v kk))) =
let open Lib.Sequence in
let open Lib.ByteSequence in
let s0 = (u32 (v nn)) ^.
(u32 (v kk) <<. (size 8)) ^.
(u32 (v p.fanout) <<. (size 16)) ^.
(u32 (v p.depth) <<. (size 24)) in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 = (u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^.
(u32 (v p.inner_length) <<. (size 24)) in
let salt_u32: lseq uint32 2 = uints_from_bytes_le (as_seq h0 (get_salt p)) in
let s4 = salt_u32.[0] in
let s5 = salt_u32.[1] in
let personal_u32: lseq uint32 2 = uints_from_bytes_le (as_seq h0 (get_personal p)) in
let s6 = personal_u32.[0] in
let s7 = personal_u32.[1] in
[@inline_let]
let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
// There seems to be something not triggering with createL, requiring the
// following lemma calls, and assert_norms to relate List.index to the
// actual elements
assert_norm (List.Tot.index l 0 == s0);
assert_norm (List.Tot.index l 1 == s1);
assert_norm (List.Tot.index l 2 == s2);
assert_norm (List.Tot.index l 3 == s3);
assert_norm (List.Tot.index l 4 == s4);
assert_norm (List.Tot.index l 5 == s5);
assert_norm (List.Tot.index l 6 == s6);
assert_norm (List.Tot.index l 7 == s7);
of_list_index l 0;
of_list_index l 1;
of_list_index l 2;
of_list_index l 3;
of_list_index l 4;
of_list_index l 5;
of_list_index l 6;
of_list_index l 7
in
aux() | {
"file_name": "code/blake2/Hacl.Impl.Blake2.Generic.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 9,
"end_line": 664,
"start_col": 0,
"start_line": 574
} | module Hacl.Impl.Blake2.Generic
open FStar.Mul
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Lib.LoopCombinators
module ST = FStar.HyperStack.ST
module Seq = Lib.Sequence
module Loops = Lib.LoopCombinators
module Spec = Spec.Blake2
open Hacl.Impl.Blake2.Constants
open Hacl.Impl.Blake2.Core
#set-options "--z3rlimit 50 --max_ifuel 0 --max_fuel 0"
noextract
let is_valid_blake2_config (a : Spec.alg) (m : m_spec) =
match a, m with
| Spec.Blake2S, M32 | Spec.Blake2S, M128
| Spec.Blake2B, M32 | Spec.Blake2B, M256 -> true
| _ -> false
inline_for_extraction noextract
let valid_m_spec (a : Spec.alg) = m:m_spec{is_valid_blake2_config a m}
/// Accessors for constants
inline_for_extraction noextract
val get_iv:
a:Spec.alg
-> s: size_t{size_v s < 8} ->
Stack (word_t a)
(requires (fun h -> True))
(ensures (fun h0 z h1 -> h0 == h1 /\
v z == v (Seq.index (Spec.ivTable a) (v s))))
let get_iv a s =
recall_contents #(Spec.pub_word_t Spec.Blake2S) #8ul ivTable_S (Spec.ivTable Spec.Blake2S);
recall_contents #(Spec.pub_word_t Spec.Blake2B) #8ul ivTable_B (Spec.ivTable Spec.Blake2B);
[@inline_let]
let ivTable: (x:glbuffer (Spec.pub_word_t a) 8ul{witnessed x (Spec.ivTable a) /\ recallable x}) =
match a with
| Spec.Blake2S -> ivTable_S
| Spec.Blake2B -> ivTable_B
in
let r = index ivTable s in
secret #(Spec.wt a) r
inline_for_extraction noextract
val get_sigma:
s: size_t{v s < 160} ->
Stack Spec.sigma_elt_t
(requires (fun h -> True))
(ensures (fun h0 z h1 -> h0 == h1 /\ z == Lib.Sequence.(Spec.sigmaTable.[v s])))
let get_sigma s =
recall_contents sigmaTable Spec.sigmaTable;
index sigmaTable s
inline_for_extraction noextract
val get_sigma_sub:
start: size_t ->
i: size_t{v i < 16 /\ v start + v i < 160} ->
Stack Spec.sigma_elt_t
(requires (fun h -> True))
(ensures (fun h0 z h1 -> h0 == h1 /\ v z == v (Seq.index Spec.sigmaTable (v start + v i))))
let get_sigma_sub start i = get_sigma (start +. i)
inline_for_extraction noextract
let rounds_t (a:Spec.alg): size_t = size (Spec.rounds a)
inline_for_extraction noextract
val size_to_word: al:Spec.alg -> s:size_t -> u:word_t al{u == Spec.nat_to_word al (v s)}
let size_to_word al s = match al with
| Spec.Blake2S -> size_to_uint32 s
| Spec.Blake2B -> size_to_uint64 s
inline_for_extraction noextract
val size_to_limb: al:Spec.alg -> s:size_t -> u:Spec.limb_t al{u == Spec.nat_to_limb al (v s)}
let size_to_limb al s = match al with
| Spec.Blake2S -> size_to_uint64 s
| Spec.Blake2B -> to_u128 (size_to_uint64 s)
/// Constants
/// Define algorithm functions
inline_for_extraction noextract
val g1: #al:Spec.alg -> #m:m_spec -> wv:state_p al m -> a:index_t -> b:index_t -> r:rotval (Spec.wt al) ->
Stack unit
(requires (fun h -> live h wv /\ a <> b))
(ensures (fun h0 _ h1 -> modifies (loc wv) h0 h1
/\ (state_v h1 wv) == Spec.g1 al (state_v h0 wv) (v a) (v b) r))
let g1 #al #m wv a b r =
let h0 = ST.get() in
let wv_a = rowi wv a in
let wv_b = rowi wv b in
xor_row wv_a wv_b;
ror_row wv_a r;
let h2 = ST.get() in
Lib.Sequence.eq_intro (state_v h2 wv) (Spec.g1 al (state_v h0 wv) (v a) (v b) r)
#push-options "--z3rlimit 100 --max_fuel 1 --max_ifuel 1"
inline_for_extraction noextract
val g2: #al:Spec.alg -> #m:m_spec -> wv:state_p al m -> a:index_t -> b:index_t -> x:row_p al m ->
Stack unit
(requires (fun h -> live h wv /\ live h x /\ disjoint wv x /\ a <> b))
(ensures (fun h0 _ h1 -> modifies (loc wv) h0 h1
/\ state_v h1 wv == Spec.g2 al (state_v h0 wv) (v a) (v b) (row_v h0 x)))
let g2 #al #m wv a b x =
let h0 = ST.get() in
let wv_a = rowi wv a in
let wv_b = rowi wv b in
add_row wv_a wv_b;
add_row wv_a x;
let h1 = ST.get() in
Lib.Sequence.eq_intro (state_v h1 wv) (Spec.g2 al (state_v h0 wv) (v a) (v b) (row_v h0 x))
#push-options "--z3rlimit 100 --max_fuel 1 --max_ifuel 1"
inline_for_extraction noextract
val g2z: #al:Spec.alg -> #m:m_spec -> wv:state_p al m -> a:index_t -> b:index_t ->
Stack unit
(requires (fun h -> live h wv /\ a <> b))
(ensures (fun h0 _ h1 -> modifies (loc wv) h0 h1
/\ state_v h1 wv == Spec.g2z al (state_v h0 wv) (v a) (v b)))
let g2z #al #m wv a b =
let h0 = ST.get() in
let wv_a = rowi wv a in
let wv_b = rowi wv b in
add_row wv_a wv_b;
let h1 = ST.get() in
Lib.Sequence.eq_intro (state_v h1 wv) (Spec.g2z al (state_v h0 wv) (v a) (v b))
inline_for_extraction noextract
val blake2_mixing : #al:Spec.alg -> #m:m_spec -> wv:state_p al m -> x:row_p al m -> y:row_p al m ->
Stack unit
(requires (fun h -> live h wv /\ live h x /\ live h y /\ disjoint wv x /\ disjoint wv y))
(ensures (fun h0 _ h1 -> modifies (loc wv) h0 h1
/\ state_v h1 wv == Spec.blake2_mixing al (state_v h0 wv) (row_v h0 x) (row_v h0 y)))
let blake2_mixing #al #m wv x y =
let h0 = ST.get() in
push_frame ();
let a = 0ul in
let b = 1ul in
let c = 2ul in
let d = 3ul in
[@inline_let]
let r0 = normalize_term (Lib.Sequence.index (Spec.rTable al) 0) in
normalize_term_spec (Lib.Sequence.index (Spec.rTable al) 0);
[@inline_let]
let r1 = normalize_term (Lib.Sequence.index (Spec.rTable al) 1) in
normalize_term_spec (Lib.Sequence.index (Spec.rTable al) 1);
[@inline_let]
let r2 = normalize_term (Lib.Sequence.index (Spec.rTable al) 2) in
normalize_term_spec (Lib.Sequence.index (Spec.rTable al) 2);
[@inline_let]
let r3 = normalize_term (Lib.Sequence.index (Spec.rTable al) 3) in
normalize_term_spec (Lib.Sequence.index (Spec.rTable al) 3);
let h1 = ST.get() in
g2 wv a b x;
g1 wv d a r0;
g2z wv c d;
g1 wv b c r1;
g2 wv a b y;
g1 wv d a r2;
g2z wv c d;
g1 wv b c r3;
let h2 = ST.get() in
pop_frame ();
let h3 = ST.get() in
assert(modifies (loc wv) h0 h3);
Lib.Sequence.eq_intro (state_v h2 wv) (Spec.blake2_mixing al (state_v h1 wv) (row_v h1 x) (row_v h1 y))
#pop-options
inline_for_extraction noextract
val diag: #a:Spec.alg -> #m:m_spec -> wv:state_p a m
-> Stack unit
(requires (fun h -> live h wv))
(ensures (fun h0 _ h1 -> modifies (loc wv) h0 h1 /\
state_v h1 wv == Spec.diag (state_v h0 wv)))
let diag #a #m wv =
let r1 = rowi wv 1ul in
let r2 = rowi wv 2ul in
let r3 = rowi wv 3ul in
let h0 = ST.get() in
permr_row r1 1ul;
permr_row r2 2ul;
permr_row r3 3ul
inline_for_extraction noextract
val undiag: #a:Spec.alg -> #m:m_spec -> wv:state_p a m
-> Stack unit
(requires (fun h -> live h wv))
(ensures (fun h0 _ h1 -> modifies (loc wv) h0 h1 /\
state_v h1 wv == Spec.undiag (state_v h0 wv)))
let undiag #a #m wv =
let r1 = rowi wv 1ul in
let r2 = rowi wv 2ul in
let r3 = rowi wv 3ul in
let h0 = ST.get() in
permr_row r1 3ul;
permr_row r2 2ul;
permr_row r3 1ul
inline_for_extraction noextract
val gather_state: #a:Spec.alg -> #ms:m_spec -> st:state_p a ms -> m:block_w a -> start:size_t{v start <= 144} -> Stack unit
(requires (fun h -> live h st /\ live h m /\ disjoint st m))
(ensures (fun h0 _ h1 -> modifies (loc st) h0 h1 /\
state_v h1 st == Spec.gather_state a (as_seq h0 m) (v start)))
inline_for_extraction noextract
let get_sigma' (start: size_t { v start <= 144 }) (i: size_t { normalize (i <=. 15ul) }):
Stack Spec.sigma_elt_t
(requires (fun h -> True))
(ensures (fun h0 z h1 ->
h0 == h1 /\ z == Lib.Sequence.(Spec.sigmaTable.[v start + v i])))
=
get_sigma (start +! i)
#push-options "--z3rlimit 500"
let gather_state #a #ms st m start =
let h0 = ST.get() in
let r0 = rowi st 0ul in
let r1 = rowi st 1ul in
let r2 = rowi st 2ul in
let r3 = rowi st 3ul in
let s0 = get_sigma' start 0ul in
let s1 = get_sigma' start 1ul in
let s2 = get_sigma' start 2ul in
let s3 = get_sigma' start 3ul in
let s4 = get_sigma' start 4ul in
let s5 = get_sigma' start 5ul in
let s6 = get_sigma' start 6ul in
let s7 = get_sigma' start 7ul in
let s8 = get_sigma' start 8ul in
let s9 = get_sigma' start 9ul in
let s10 = get_sigma' start 10ul in
let s11 = get_sigma' start 11ul in
let s12 = get_sigma' start 12ul in
let s13 = get_sigma' start 13ul in
let s14 = get_sigma' start 14ul in
let s15 = get_sigma' start 15ul in
let h1 = ST.get() in
gather_row r0 m s0 s2 s4 s6;
let h2 = ST.get() in
gather_row r1 m s1 s3 s5 s7;
let h3 = ST.get() in
gather_row r2 m s8 s10 s12 s14;
let h4 = ST.get() in
gather_row r3 m s9 s11 s13 s15;
let h5 = ST.get() in
assert(modifies (loc st) h0 h5);
Lib.Sequence.eq_intro (state_v h5 st) (Spec.gather_state a (as_seq h0 m) (v start))
inline_for_extraction noextract
val blake2_round : #al:Spec.alg -> #ms:m_spec -> wv:state_p al ms -> m:block_w al -> i:size_t ->
Stack unit
(requires (fun h -> live h wv /\ live h m /\ disjoint wv m))
(ensures (fun h0 _ h1 -> modifies (loc wv) h0 h1
/\ state_v h1 wv == Spec.blake2_round al (as_seq h0 m) (v i) (state_v h0 wv)))
let blake2_round #al #ms wv m i =
push_frame();
let start_idx = (i %. size 10) *. size 16 in
assert (v start_idx == (v i % 10) * 16);
assert (v start_idx <= 144);
let m_st = alloc_state al ms in
gather_state m_st m start_idx;
let x = rowi m_st 0ul in
let y = rowi m_st 1ul in
let z = rowi m_st 2ul in
let w = rowi m_st 3ul in
let h1 = ST.get() in
assert (disjoint wv m_st);
assert (disjoint m_st wv);
assert (disjoint x wv);
assert (disjoint wv x);
assert (disjoint y wv);
assert (disjoint wv y);
assert (disjoint z wv);
assert (disjoint wv z);
assert (disjoint w wv);
assert (disjoint wv w);
blake2_mixing wv x y;
diag wv;
blake2_mixing wv z w;
undiag wv;
pop_frame ()
inline_for_extraction noextract
val blake2_compress0:
#al:Spec.alg
-> m_s: block_p al
-> m_w: block_w al
-> Stack unit
(requires (fun h -> live h m_s /\ live h m_w /\ disjoint m_s m_w))
(ensures (fun h0 _ h1 -> modifies (loc m_w) h0 h1
/\ as_seq h1 m_w == Spec.blake2_compress0 al (as_seq h0 m_s)))
let blake2_compress0 #al m_s m_w =
uints_from_bytes_le m_w m_s
inline_for_extraction noextract
val blake2_compress1:
#al:Spec.alg
-> #m:m_spec
-> wv: state_p al m
-> s_iv: state_p al m
-> offset: Spec.limb_t al
-> flag: bool ->
Stack unit
(requires (fun h -> live h wv /\ live h s_iv /\ disjoint wv s_iv))
(ensures (fun h0 _ h1 -> modifies (loc wv) h0 h1
/\ state_v h1 wv == Spec.blake2_compress1 al (state_v h0 s_iv) offset flag))
let blake2_compress1 #al #m wv s_iv offset flag =
let h0 = ST.get() in
push_frame();
let mask = alloc_row al m in
[@inline_let]
let wv_12 = Spec.limb_to_word al offset in
[@inline_let]
let wv_13 = Spec.limb_to_word al (offset >>. (size (bits (Spec.wt al)))) in
// SH: TODO: for some reason, ``ones`` below doesn't get inlined by KaRaMeL,
// causing an extraction problem. The 3 lines below are a hack to fix
// extraction for the time being:
// [> let wv_14 = if flag then (ones (Spec.wt al) SEC) else (Spec.zero al) in
// After investigation, it is because ones is [@(strict_on_arguments [0])],
// and so isn't unfolded if its first argument is not normalized to a constant.
// However, the first argument should always be normalized (I checked the
// output generated by KaRaMeL and the definitions).
(**) normalize_term_spec (Spec.wt al);
[@inline_let] let wt_al = normalize_term (Spec.wt al) in
let wv_14 = if flag then ones wt_al SEC else (Spec.zero al) in
// end of the TODO
let wv_15 = Spec.zero al in
create_row mask wv_12 wv_13 wv_14 wv_15;
copy_state wv s_iv;
let wv3 = rowi wv 3ul in
xor_row wv3 mask;
pop_frame();
let h1 = ST.get() in
assert(modifies (loc wv) h0 h1);
Lib.Sequence.eq_intro (state_v h1 wv) (Spec.blake2_compress1 al (state_v h0 s_iv) offset flag)
inline_for_extraction noextract
val blake2_compress2 :
#al:Spec.alg
-> #ms:m_spec
-> wv: state_p al ms
-> m: block_w al ->
Stack unit
(requires (fun h -> live h wv /\ live h m /\ disjoint wv m))
(ensures (fun h0 _ h1 -> modifies1 wv h0 h1
/\ state_v h1 wv == Spec.blake2_compress2 al (state_v h0 wv) (as_seq h0 m)))
#push-options "--z3rlimit 400"
let blake2_compress2 #al #ms wv m =
let h0 = ST.get () in
[@inline_let]
let a_spec = Spec.state al in
[@inline_let]
let refl h = state_v h wv in
[@inline_let]
let footprint = Ghost.hide(loc wv) in
[@inline_let]
let spec h = Spec.blake2_round al h.[|m|] in
loop_refl h0 (rounds_t al) a_spec refl footprint spec
(fun i ->
Loops.unfold_repeati (Spec.rounds al) (spec h0) (state_v h0 wv) (v i);
blake2_round wv m i)
#pop-options
inline_for_extraction noextract
val blake2_compress3 :
#al:Spec.alg
-> #ms:m_spec
-> s_iv:state_p al ms
-> wv:state_p al ms ->
Stack unit
(requires (fun h -> live h s_iv /\ live h wv /\ disjoint s_iv wv))
(ensures (fun h0 _ h1 -> modifies (loc s_iv) h0 h1
/\ state_v h1 s_iv == Spec.blake2_compress3 al (state_v h0 wv) (state_v h0 s_iv)))
let blake2_compress3 #al #ms s_iv wv =
let h0 = ST.get() in
let s0 = rowi s_iv 0ul in
let s1 = rowi s_iv 1ul in
let r0 = rowi wv 0ul in
let r1 = rowi wv 1ul in
let r2 = rowi wv 2ul in
let r3 = rowi wv 3ul in
assert (disjoint s0 wv);
assert (disjoint wv s0);
assert (disjoint s1 wv);
assert (disjoint wv s1);
assert (disjoint r0 s0);
assert (disjoint r2 s0);
assert (disjoint r1 s1);
assert (disjoint r3 s1);
xor_row s0 r0;
let h1 = ST.get() in
xor_row s0 r2;
let h2 = ST.get() in
xor_row s1 r1;
let h3 = ST.get() in
xor_row s1 r3;
let h4 = ST.get() in
assert (modifies (loc s_iv) h0 h4);
let open Lib.Sequence in
assert (row_v h0 r0 == (state_v h0 wv).[0]);
assert (row_v h1 r2 == (state_v h0 wv).[2]);
assert (row_v h4 s0 == Spec.(((state_v h0 s_iv).[0] ^| (state_v h0 wv).[0]) ^| (state_v h0 wv).[2]));
assert (row_v h4 s1 == Spec.(((state_v h0 s_iv).[1] ^| (state_v h0 wv).[1]) ^| (state_v h0 wv).[3]));
eq_intro (state_v h2 s_iv) ((state_v h0 s_iv).[0] <- row_v h4 s0);
eq_intro (state_v h4 s_iv) ((state_v h2 s_iv).[1] <- row_v h4 s1);
eq_intro (state_v h4 s_iv) (Spec.blake2_compress3 al (state_v h0 wv) (state_v h0 s_iv))
inline_for_extraction noextract
let compress_t (al:Spec.alg) (ms:m_spec) =
wv:state_p al ms
-> s: state_p al ms
-> m: block_p al
-> offset: Spec.limb_t al
-> flag: bool ->
Stack unit
(requires (fun h -> live h wv /\ live h s /\ live h m /\ disjoint s m /\ disjoint wv s /\ disjoint wv m))
(ensures (fun h0 _ h1 -> modifies (loc s |+| loc wv) h0 h1
/\ state_v h1 s == Spec.blake2_compress al (state_v h0 s) h0.[|m|] offset flag))
inline_for_extraction noextract
val blake2_compress: #al:Spec.alg -> #ms:m_spec -> compress_t al ms
let blake2_compress #al #ms wv s m offset flag =
push_frame();
let m_w = create 16ul (Spec.zero al) in
blake2_compress0 #al m m_w;
blake2_compress1 wv s offset flag;
blake2_compress2 wv m_w;
blake2_compress3 s wv;
pop_frame()
inline_for_extraction noextract
let blake2_update_block_st (al:Spec.alg) (ms:m_spec) =
wv:state_p al ms
-> hash: state_p al ms
-> flag: bool
-> totlen: Spec.limb_t al{v totlen <= Spec.max_limb al}
-> d: block_p al ->
Stack unit
(requires (fun h -> live h wv /\ live h hash /\ live h d /\ disjoint hash d /\ disjoint wv hash /\ disjoint wv d))
(ensures (fun h0 _ h1 -> modifies (loc hash |+| loc wv) h0 h1
/\ state_v h1 hash == Spec.blake2_update_block al flag (v totlen) h0.[|d|] (state_v h0 hash)))
inline_for_extraction noextract
val blake2_update_block: #al:Spec.alg -> #ms:m_spec -> blake2_update_block_st al ms
let blake2_update_block #al #ms wv hash flag totlen d =
blake2_compress wv hash d totlen flag
inline_for_extraction noextract
let blake2_update1_st (al:Spec.alg) (ms:m_spec) =
#len:size_t
-> wv: state_p al ms
-> hash: state_p al ms
-> prev: Spec.limb_t al{v prev + v len <= Spec.max_limb al}
-> d: lbuffer uint8 len
-> i: size_t{v i < length d / Spec.size_block al} ->
Stack unit
(requires (fun h -> live h wv /\ live h hash /\ live h d /\ disjoint hash d /\ disjoint wv hash /\ disjoint wv d))
(ensures (fun h0 _ h1 -> modifies (loc hash |+| loc wv) h0 h1
/\ state_v h1 hash == Spec.blake2_update1 al (v prev) h0.[|d|] (v i) (state_v h0 hash)))
inline_for_extraction noextract
val blake2_update1: #al:Spec.alg -> #ms:m_spec -> blake2_update_block: blake2_update_block_st al ms -> blake2_update1_st al ms
let blake2_update1 #al #ms blake2_update_block #len wv hash prev d i =
let totlen = prev +. size_to_limb al ((i+!1ul) *! size_block al) in
assert (v totlen == v prev + (v i + 1) * Spec.size_block al);
let b = sub d (i *. size_block al) (size_block al) in
let h = ST.get() in
assert (as_seq h b == Spec.get_blocki al (as_seq h d) (v i));
blake2_update_block wv hash false totlen b
inline_for_extraction noextract
let blake2_update_last_st (al:Spec.alg) (ms:m_spec) =
#len:size_t
-> wv: state_p al ms
-> hash: state_p al ms
-> prev: Spec.limb_t al{v prev + v len <= Spec.max_limb al}
-> rem: size_t {v rem <= v len /\ v rem <= Spec.size_block al}
-> d: lbuffer uint8 len ->
Stack unit
(requires (fun h -> live h wv /\ live h hash /\ live h d /\ disjoint hash d /\ disjoint wv hash /\ disjoint wv d))
(ensures (fun h0 _ h1 -> modifies (loc hash |+| loc wv) h0 h1
/\ state_v h1 hash == Spec.blake2_update_last al (v prev) (v rem) h0.[|d|] (state_v h0 hash)))
inline_for_extraction noextract
val blake2_update_last:
#al:Spec.alg
-> #ms:m_spec
-> blake2_update_block: blake2_update_block_st al ms
-> blake2_update_last_st al ms
let blake2_update_last #al #ms blake2_update_block #len wv hash prev rem d =
let h0 = ST.get () in
[@inline_let]
let spec _ h1 = state_v h1 hash == Spec.blake2_update_last al (v prev) (v rem) h0.[|d|] (state_v h0 hash) in
salloc1 h0 (size_block al) (u8 0) (Ghost.hide (loc hash |+| loc wv)) spec
(fun last_block ->
let last = sub d (len -! rem) rem in
let h1 = ST.get() in
update_sub last_block 0ul rem last;
let h2 = ST.get() in
as_seq_gsub h1 d (len -! rem) rem;
assert (as_seq h1 last == Seq.sub (as_seq h1 d) (v len - v rem) (v rem));
assert (as_seq h1 last == Seq.slice (as_seq h0 d) (v len - v rem) (v len));
assert (as_seq h2 last_block == Spec.get_last_padded_block al (as_seq h0 d) (v rem));
let totlen = prev +. (size_to_limb al len) in
blake2_update_block wv hash true totlen last_block;
let h3 = ST.get() in
assert (v totlen == v prev + v len);
assert (state_v h3 hash == Spec.blake2_update_block al true (v totlen) (as_seq h2 last_block) (state_v h0 hash)))
inline_for_extraction noextract
let blake2_init_st (al:Spec.alg) (ms:m_spec) =
hash: state_p al ms
-> kk: size_t{v kk <= Spec.max_key al}
-> nn: size_t{1 <= v nn /\ v nn <= Spec.max_output al} ->
Stack unit
(requires (fun h -> live h hash))
(ensures (fun h0 _ h1 -> modifies (loc hash) h0 h1 /\
state_v h1 hash == Spec.blake2_init_hash al (Spec.blake2_default_params al) (v kk) (v nn)))
inline_for_extraction noextract
val serialize_params (al:Spec.alg)
(kk:size_t{v kk <= Spec.max_key al})
(nn: size_t{1 <= v nn /\ v nn <= Spec.max_output al})
(p: blake2_params al)
(b: lbuffer (word_t al) 8ul)
: Stack unit
(requires fun h ->
live h b /\
blake2_params_inv h p /\
LowStar.Buffer.loc_disjoint (loc b) (blake2_params_loc p) /\
as_seq h b == Seq.create 8 (Spec.nat_to_word al 0)
)
(ensures fun h0 _ h1 ->
modifies (loc b) h0 h1 /\
as_seq h1 b == Spec.serialize_blake2_params
(Spec.set_key_length (Spec.set_digest_length (blake2_params_v h0 p) (v nn)) (v kk)))
#push-options "--z3rlimit 100 --fuel 0" | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"LowStar.Modifies.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Blake2.Core.fsti.checked",
"Hacl.Impl.Blake2.Constants.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Blake2.Generic.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2.Core",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2.Constants",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Blake2",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
kk:
Lib.IntTypes.size_t
{Lib.IntTypes.v kk <= Spec.Blake2.Definitions.max_key Spec.Blake2.Definitions.Blake2S} ->
nn:
Lib.IntTypes.size_t
{ 1 <= Lib.IntTypes.v nn /\
Lib.IntTypes.v nn <= Spec.Blake2.Definitions.max_output Spec.Blake2.Definitions.Blake2S } ->
p: Hacl.Impl.Blake2.Core.blake2_params Spec.Blake2.Definitions.Blake2S ->
b: Lib.Buffer.lbuffer (Hacl.Impl.Blake2.Core.word_t Spec.Blake2.Definitions.Blake2S) 8ul
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Spec.Blake2.Definitions.max_key",
"Spec.Blake2.Definitions.Blake2S",
"Prims.l_and",
"Spec.Blake2.Definitions.max_output",
"Hacl.Impl.Blake2.Core.blake2_params",
"Lib.Buffer.lbuffer",
"Hacl.Impl.Blake2.Core.word_t",
"FStar.UInt32.__uint_to_t",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Lib.Sequence.equal",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Spec.Blake2.serialize_blake2s_params",
"Spec.Blake2.Definitions.set_key_length",
"Spec.Blake2.Definitions.set_digest_length",
"Hacl.Impl.Blake2.Core.blake2_params_v",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Lib.Sequence.of_list_index",
"Lib.IntTypes.int_t",
"Lib.IntTypes.SEC",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"FStar.List.Tot.Base.index",
"Prims.int",
"FStar.List.Tot.Base.length",
"Prims.list",
"Prims.Cons",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.op_String_Access",
"Lib.Sequence.lseq",
"Lib.ByteSequence.uints_from_bytes_le",
"Lib.IntTypes.uint8",
"Hacl.Impl.Blake2.Core.personal_len",
"Hacl.Impl.Blake2.Core.get_personal",
"Hacl.Impl.Blake2.Core.salt_len",
"Hacl.Impl.Blake2.Core.get_salt",
"Lib.IntTypes.op_Hat_Dot",
"Lib.IntTypes.u32",
"Lib.IntTypes.U16",
"Hacl.Impl.Blake2.Core.__proj__Mkblake2s_params__item__xof_length",
"Lib.IntTypes.op_Less_Less_Dot",
"Lib.IntTypes.U8",
"Hacl.Impl.Blake2.Core.__proj__Mkblake2s_params__item__node_depth",
"Lib.IntTypes.size",
"Hacl.Impl.Blake2.Core.__proj__Mkblake2s_params__item__inner_length",
"Hacl.Impl.Blake2.Core.__proj__Mkblake2s_params__item__node_offset",
"Hacl.Impl.Blake2.Core.__proj__Mkblake2s_params__item__leaf_length",
"Hacl.Impl.Blake2.Core.__proj__Mkblake2s_params__item__fanout",
"Hacl.Impl.Blake2.Core.__proj__Mkblake2s_params__item__depth",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Lib.Buffer.op_Array_Assignment",
"Lib.ByteBuffer.uints_from_bytes_le",
"Spec.Blake2.Definitions.wt",
"Hacl.Impl.Blake2.Core.__proj__Mkblake2s_params__item__personal",
"Lib.Buffer.lbuffer_t",
"Lib.Buffer.sub",
"Hacl.Impl.Blake2.Core.__proj__Mkblake2s_params__item__salt",
"Lib.IntTypes.to_u32",
"Lib.IntTypes.shift_left",
"Lib.Buffer.live",
"Hacl.Impl.Blake2.Core.blake2_params_inv",
"LowStar.Monotonic.Buffer.loc_disjoint",
"Lib.Buffer.loc",
"Hacl.Impl.Blake2.Core.blake2_params_loc",
"Lib.Sequence.create",
"Lib.Buffer.modifies",
"Spec.Blake2.serialize_blake2_params"
] | [] | false | true | false | false | false | let serialize_params_blake2s
(kk: size_t{v kk <= Spec.max_key Spec.Blake2S})
(nn: size_t{1 <= v nn /\ v nn <= Spec.max_output Spec.Blake2S})
(p: blake2_params Spec.Blake2S)
(b: lbuffer (word_t Spec.Blake2S) 8ul)
: Stack unit
(requires
fun h ->
live h b /\ blake2_params_inv h p /\
LowStar.Buffer.loc_disjoint (loc b) (blake2_params_loc p) /\
as_seq h b == Seq.create 8 (u32 0))
(ensures
fun h0 _ h1 ->
modifies (loc b) h0 h1 /\
as_seq h1 b ==
Spec.serialize_blake2_params (Spec.set_key_length (Spec.set_digest_length (blake2_params_v
h0
p)
(v nn))
(v kk))) =
| let h0 = ST.get () in
[@@ inline_let ]let kk_shift_8 = shift_left (to_u32 kk) (size 8) in
[@@ inline_let ]let fanout_shift_16 = shift_left (to_u32 p.fanout) (size 16) in
[@@ inline_let ]let depth_shift_24 = shift_left (to_u32 p.depth) (size 24) in
[@@ inline_let ]let v0 = (to_u32 nn) ^. kk_shift_8 ^. fanout_shift_16 ^. depth_shift_24 in
[@@ inline_let ]let v1 = p.leaf_length in
[@@ inline_let ]let v2 = p.node_offset in
[@@ inline_let ]let node_depth_shift_16 = shift_left (to_u32 p.node_depth) (size 16) in
[@@ inline_let ]let inner_length_shift_16 = shift_left (to_u32 p.inner_length) (size 24) in
[@@ inline_let ]let v3 = (to_u32 p.xof_length) ^. node_depth_shift_16 ^. inner_length_shift_16 in
uints_from_bytes_le (sub b 4ul 2ul) p.salt;
uints_from_bytes_le (sub b 6ul 2ul) p.personal;
b.(0ul) <- v0;
b.(1ul) <- v1;
b.(2ul) <- v2;
b.(3ul) <- v3;
let h1 = ST.get () in
let aux ()
: Lemma
((as_seq h1 b)
`Seq.equal`
(Spec.serialize_blake2s_params (Spec.set_key_length (Spec.set_digest_length (blake2_params_v h0
p)
(v nn))
(v kk)))) =
let open Lib.Sequence in
let open Lib.ByteSequence in
let s0 =
(u32 (v nn)) ^.
(u32 (v kk) <<. (size 8)) ^. (u32 (v p.fanout) <<. (size 16)) ^. (u32 (v p.depth) <<. (size 24))
in
let s1 = p.leaf_length in
let s2 = p.node_offset in
let s3 =
(u32 (v p.xof_length)) ^.
(u32 (v p.node_depth) <<. (size 16)) ^. (u32 (v p.inner_length) <<. (size 24))
in
let salt_u32:lseq uint32 2 = uints_from_bytes_le (as_seq h0 (get_salt p)) in
let s4 = salt_u32.[ 0 ] in
let s5 = salt_u32.[ 1 ] in
let personal_u32:lseq uint32 2 = uints_from_bytes_le (as_seq h0 (get_personal p)) in
let s6 = personal_u32.[ 0 ] in
let s7 = personal_u32.[ 1 ] in
[@@ inline_let ]let l = [s0; s1; s2; s3; s4; s5; s6; s7] in
assert_norm (List.Tot.length l == 8);
assert_norm (List.Tot.index l 0 == s0);
assert_norm (List.Tot.index l 1 == s1);
assert_norm (List.Tot.index l 2 == s2);
assert_norm (List.Tot.index l 3 == s3);
assert_norm (List.Tot.index l 4 == s4);
assert_norm (List.Tot.index l 5 == s5);
assert_norm (List.Tot.index l 6 == s6);
assert_norm (List.Tot.index l 7 == s7);
of_list_index l 0;
of_list_index l 1;
of_list_index l 2;
of_list_index l 3;
of_list_index l 4;
of_list_index l 5;
of_list_index l 6;
of_list_index l 7
in
aux () | false |
DependentBoolRefinement.fst | DependentBoolRefinement.open_exp' | val open_exp' (e v: src_exp) (n: index) : Tot src_exp (decreases e) | val open_exp' (e v: src_exp) (n: index) : Tot src_exp (decreases e) | let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1)) | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 70,
"end_line": 79,
"start_col": 0,
"start_line": 62
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
e: DependentBoolRefinement.src_exp ->
v: DependentBoolRefinement.src_exp ->
n: DependentBoolRefinement.index
-> Prims.Tot DependentBoolRefinement.src_exp | Prims.Tot | [
"total",
""
] | [
"open_exp'",
"open_ty'"
] | [
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.index",
"Prims.bool",
"DependentBoolRefinement.var",
"DependentBoolRefinement.EVar",
"Prims.op_Equality",
"DependentBoolRefinement.EBVar",
"DependentBoolRefinement.EIf",
"DependentBoolRefinement.open_exp'",
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.ELam",
"DependentBoolRefinement.open_ty'",
"Prims.op_Addition",
"DependentBoolRefinement.EApp"
] | [
"mutual recursion"
] | false | false | false | true | false | let rec open_exp' (e v: src_exp) (n: index) : Tot src_exp (decreases e) =
| match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n) | false |
DependentBoolRefinement.fst | DependentBoolRefinement.lookup | val lookup (e: list (var & 'a)) (x: var) : option 'a | val lookup (e: list (var & 'a)) (x: var) : option 'a | let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 59,
"end_line": 154,
"start_col": 0,
"start_line": 150
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | e: Prims.list (DependentBoolRefinement.var * 'a) -> x: DependentBoolRefinement.var
-> FStar.Pervasives.Native.option 'a | Prims.Tot | [
"total"
] | [] | [
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"DependentBoolRefinement.var",
"FStar.Pervasives.Native.None",
"Prims.op_Equality",
"FStar.Pervasives.Native.Some",
"Prims.bool",
"DependentBoolRefinement.lookup",
"FStar.Pervasives.Native.option"
] | [
"recursion"
] | false | false | false | true | false | let rec lookup (e: list (var & 'a)) (x: var) : option 'a =
| match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x | false |
DependentBoolRefinement.fst | DependentBoolRefinement.close_ty' | val close_ty' (t: src_ty) (v: var) (n: index) : Tot src_ty (decreases t) | val close_ty' (t: src_ty) (v: var) (n: index) : Tot src_ty (decreases t) | let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1)) | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 72,
"end_line": 98,
"start_col": 0,
"start_line": 81
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
t: DependentBoolRefinement.src_ty ->
v: DependentBoolRefinement.var ->
n: DependentBoolRefinement.index
-> Prims.Tot DependentBoolRefinement.src_ty | Prims.Tot | [
"total",
""
] | [
"close_exp'",
"close_ty'"
] | [
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.var",
"DependentBoolRefinement.index",
"DependentBoolRefinement.TBool",
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.TRefineBool",
"DependentBoolRefinement.close_exp'",
"Prims.op_Addition",
"DependentBoolRefinement.TArrow",
"DependentBoolRefinement.close_ty'"
] | [
"mutual recursion"
] | false | false | false | true | false | let rec close_ty' (t: src_ty) (v: var) (n: index) : Tot src_ty (decreases t) =
| match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1)) | false |
DependentBoolRefinement.fst | DependentBoolRefinement.fresh | val fresh (e: list (var & 'a)) : var | val fresh (e: list (var & 'a)) : var | let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 25,
"end_line": 175,
"start_col": 0,
"start_line": 170
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | e: Prims.list (DependentBoolRefinement.var * 'a) -> DependentBoolRefinement.var | Prims.Tot | [
"total"
] | [] | [
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"DependentBoolRefinement.var",
"Prims.op_Addition",
"DependentBoolRefinement.max",
"DependentBoolRefinement.fresh"
] | [
"recursion"
] | false | false | false | true | false | let rec fresh (e: list (var & 'a)) : var =
| match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl | false |
DependentBoolRefinement.fst | DependentBoolRefinement.src_env_ok | val src_env_ok (s: src_env) : bool | val src_env_ok (s: src_env) : bool | let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 56,
"end_line": 160,
"start_col": 0,
"start_line": 156
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s: DependentBoolRefinement.src_env -> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"DependentBoolRefinement.src_env",
"DependentBoolRefinement.var",
"DependentBoolRefinement.binding",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.op_AmpAmp",
"FStar.Pervasives.Native.uu___is_None",
"DependentBoolRefinement.lookup",
"DependentBoolRefinement.src_env_ok",
"Prims.bool"
] | [
"recursion"
] | false | false | false | true | false | let rec src_env_ok (s: src_env) : bool =
| match s with
| [] -> true
| (x, _) :: tl -> None? (lookup tl x) && src_env_ok tl | false |
DependentBoolRefinement.fst | DependentBoolRefinement.fresh_is_fresh | val fresh_is_fresh (e: src_env) : Lemma (None? (lookup e (fresh e))) | val fresh_is_fresh (e: src_env) : Lemma (None? (lookup e (fresh e))) | let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e) | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 53,
"end_line": 208,
"start_col": 0,
"start_line": 202
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | e: DependentBoolRefinement.src_env
-> FStar.Pervasives.Lemma
(ensures None? (DependentBoolRefinement.lookup e (DependentBoolRefinement.fresh e))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"DependentBoolRefinement.src_env",
"DependentBoolRefinement.lookup",
"DependentBoolRefinement.binding",
"DependentBoolRefinement.fresh",
"FStar.Classical.forall_intro",
"FStar.Pervasives.Native.tuple2",
"DependentBoolRefinement.var",
"Prims.l_imp",
"FStar.List.Tot.Base.memP",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.Pervasives.Native.fst",
"DependentBoolRefinement.fresh_not_mem",
"Prims.unit",
"DependentBoolRefinement.lookup_mem",
"Prims.l_True",
"Prims.squash",
"FStar.Pervasives.Native.uu___is_None",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let fresh_is_fresh (e: src_env) : Lemma (None? (lookup e (fresh e))) =
| match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e) | false |
DependentBoolRefinement.fst | DependentBoolRefinement.lookup_mem | val lookup_mem (e: list (var & 'a)) (x: var)
: Lemma (requires Some? (lookup e x)) (ensures exists elt. L.memP elt e /\ fst elt == x) | val lookup_mem (e: list (var & 'a)) (x: var)
: Lemma (requires Some? (lookup e x)) (ensures exists elt. L.memP elt e /\ fst elt == x) | let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
) | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 9,
"end_line": 200,
"start_col": 0,
"start_line": 183
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | e: Prims.list (DependentBoolRefinement.var * 'a) -> x: DependentBoolRefinement.var
-> FStar.Pervasives.Lemma (requires Some? (DependentBoolRefinement.lookup e x))
(ensures
exists (elt: (DependentBoolRefinement.var * 'a)).
FStar.List.Tot.Base.memP elt e /\ FStar.Pervasives.Native.fst elt == x) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"DependentBoolRefinement.var",
"DependentBoolRefinement.lookup",
"Prims._assert",
"FStar.List.Tot.Base.memP",
"FStar.Pervasives.Native.option",
"FStar.Classical.Sugar.exists_elim",
"Prims.l_and",
"Prims.eq2",
"FStar.Pervasives.Native.fst",
"Prims.l_Exists",
"Prims.squash",
"FStar.Classical.Sugar.exists_intro",
"Prims.unit",
"DependentBoolRefinement.lookup_mem",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec lookup_mem (e: list (var & 'a)) (x: var)
: Lemma (requires Some? (lookup e x)) (ensures exists elt. L.memP elt e /\ fst elt == x) =
| match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt.
L.memP elt tl /\ fst elt == x
returns _
with _.
(introduce exists elt.L.memP elt e /\ fst elt == x
with elt
and ()) | false |
DependentBoolRefinement.fst | DependentBoolRefinement.freevars | val freevars (e: src_exp) : FStar.Set.set var | val freevars (e: src_exp) : FStar.Set.set var | let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 33,
"end_line": 40,
"start_col": 0,
"start_line": 26
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | e: DependentBoolRefinement.src_exp -> FStar.Set.set DependentBoolRefinement.var | Prims.Tot | [
"total"
] | [
"freevars",
"freevars_ty"
] | [
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.var",
"FStar.Set.singleton",
"Prims.bool",
"FStar.Set.empty",
"DependentBoolRefinement.index",
"FStar.Set.union",
"DependentBoolRefinement.freevars",
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.freevars_ty",
"FStar.Set.set"
] | [
"mutual recursion"
] | false | false | false | true | false | let rec freevars (e: src_exp) : FStar.Set.set var =
| match e with
| EVar v -> Set.singleton v
| EBool _ | EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2) | false |
DependentBoolRefinement.fst | DependentBoolRefinement.fresh_not_mem | val fresh_not_mem (e: list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt) | val fresh_not_mem (e: list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt) | let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 181,
"start_col": 0,
"start_line": 177
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | e: Prims.list (DependentBoolRefinement.var * 'a) -> elt: (DependentBoolRefinement.var * 'a)
-> FStar.Pervasives.Lemma
(ensures
FStar.List.Tot.Base.memP elt e ==>
DependentBoolRefinement.fresh e > FStar.Pervasives.Native.fst elt) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"DependentBoolRefinement.var",
"DependentBoolRefinement.fresh_not_mem",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_imp",
"FStar.List.Tot.Base.memP",
"Prims.b2t",
"Prims.op_GreaterThan",
"DependentBoolRefinement.fresh",
"FStar.Pervasives.Native.fst",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec fresh_not_mem (e: list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt) =
| match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt | false |
DependentBoolRefinement.fst | DependentBoolRefinement.elab_binding | val elab_binding (b: binding) : R.term | val elab_binding (b: binding) : R.term | let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2 | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 316,
"start_col": 0,
"start_line": 312
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | b: DependentBoolRefinement.binding -> FStar.Stubs.Reflection.Types.term | Prims.Tot | [
"total"
] | [] | [
"DependentBoolRefinement.binding",
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.elab_ty",
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.elab_eqn",
"FStar.Stubs.Reflection.Types.term"
] | [] | false | false | false | true | false | let elab_binding (b: binding) : R.term =
| match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2 | false |
Vale.Arch.Heap.fst | Vale.Arch.Heap.heap_impl | val heap_impl : Type u#1 | val heap_impl : Type u#1 | let heap_impl = vale_full_heap | {
"file_name": "vale/code/arch/Vale.Arch.Heap.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 30,
"end_line": 8,
"start_col": 0,
"start_line": 8
} | module Vale.Arch.Heap
open FStar.Mul
open Vale.Interop
open Vale.Arch.HeapImpl
module Map16 = Vale.Lib.Map16
friend Vale.Arch.HeapImpl | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Map16.fsti.checked",
"Vale.Interop.fsti.checked",
"Vale.Arch.HeapImpl.fst.checked",
"Vale.Arch.HeapImpl.fst.checked",
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Arch.Heap.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Heap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Type | Prims.Tot | [
"total"
] | [] | [
"Vale.Arch.HeapImpl.vale_full_heap"
] | [] | false | false | false | true | true | let heap_impl =
| vale_full_heap | false |
Vale.Arch.Heap.fst | Vale.Arch.Heap.heap_taint | val heap_taint (hi:heap_impl) : memTaint_t | val heap_taint (hi:heap_impl) : memTaint_t | let heap_taint hi = hi.vf_layout.vl_taint | {
"file_name": "vale/code/arch/Vale.Arch.Heap.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 41,
"end_line": 12,
"start_col": 0,
"start_line": 12
} | module Vale.Arch.Heap
open FStar.Mul
open Vale.Interop
open Vale.Arch.HeapImpl
module Map16 = Vale.Lib.Map16
friend Vale.Arch.HeapImpl
let heap_impl = vale_full_heap
let heap_get hi = hi.vf_heap.mh | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Map16.fsti.checked",
"Vale.Interop.fsti.checked",
"Vale.Arch.HeapImpl.fst.checked",
"Vale.Arch.HeapImpl.fst.checked",
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Arch.Heap.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Heap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | hi: Vale.Arch.Heap.heap_impl -> Vale.Arch.HeapTypes_s.memTaint_t | Prims.Tot | [
"total"
] | [] | [
"Vale.Arch.Heap.heap_impl",
"Vale.Arch.HeapImpl.__proj__Mkvale_heap_layout__item__vl_taint",
"Vale.Arch.HeapImpl.__proj__Mkvale_full_heap__item__vf_layout",
"Vale.Arch.HeapTypes_s.memTaint_t"
] | [] | false | false | false | true | false | let heap_taint hi =
| hi.vf_layout.vl_taint | false |
Vale.Arch.Heap.fst | Vale.Arch.Heap.heap_get | val heap_get (hi:heap_impl) : machine_heap | val heap_get (hi:heap_impl) : machine_heap | let heap_get hi = hi.vf_heap.mh | {
"file_name": "vale/code/arch/Vale.Arch.Heap.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 31,
"end_line": 10,
"start_col": 0,
"start_line": 10
} | module Vale.Arch.Heap
open FStar.Mul
open Vale.Interop
open Vale.Arch.HeapImpl
module Map16 = Vale.Lib.Map16
friend Vale.Arch.HeapImpl
let heap_impl = vale_full_heap | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Map16.fsti.checked",
"Vale.Interop.fsti.checked",
"Vale.Arch.HeapImpl.fst.checked",
"Vale.Arch.HeapImpl.fst.checked",
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Arch.Heap.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Heap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | hi: Vale.Arch.Heap.heap_impl -> Vale.Arch.MachineHeap_s.machine_heap | Prims.Tot | [
"total"
] | [] | [
"Vale.Arch.Heap.heap_impl",
"Vale.Arch.HeapImpl.__proj__ValeHeap__item__mh",
"Vale.Arch.HeapImpl.__proj__Mkvale_full_heap__item__vf_heap",
"Vale.Arch.MachineHeap_s.machine_heap"
] | [] | false | false | false | true | false | let heap_get hi =
| hi.vf_heap.mh | false |
DependentBoolRefinement.fst | DependentBoolRefinement.elab_exp | val elab_exp (e: src_exp) : Tot R.term | val elab_exp (e: src_exp) : Tot R.term | let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement) | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 40,
"end_line": 273,
"start_col": 0,
"start_line": 219
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | e: DependentBoolRefinement.src_exp -> FStar.Stubs.Reflection.Types.term | Prims.Tot | [
"total"
] | [
"elab_exp",
"elab_ty"
] | [
"DependentBoolRefinement.src_exp",
"FStar.Stubs.Reflection.V2.Builtins.pack_ln",
"FStar.Stubs.Reflection.V2.Data.Tv_Const",
"FStar.Stubs.Reflection.V2.Data.C_True",
"FStar.Stubs.Reflection.V2.Data.C_False",
"DependentBoolRefinement.index",
"FStar.Stubs.Reflection.V2.Data.Tv_BVar",
"FStar.Stubs.Reflection.Types.bv",
"FStar.Stubs.Reflection.V2.Builtins.pack_bv",
"FStar.Reflection.Typing.make_bv",
"DependentBoolRefinement.var",
"FStar.Stubs.Reflection.V2.Data.Tv_Var",
"FStar.Stubs.Reflection.Types.namedv",
"FStar.Stubs.Reflection.V2.Builtins.pack_namedv",
"FStar.Reflection.Typing.make_namedv",
"DependentBoolRefinement.src_ty",
"FStar.Stubs.Reflection.V2.Data.Tv_Abs",
"FStar.Reflection.Typing.mk_simple_binder",
"FStar.Reflection.Typing.pp_name_default",
"FStar.Stubs.Reflection.Types.term",
"DependentBoolRefinement.elab_exp",
"DependentBoolRefinement.elab_ty",
"FStar.Stubs.Reflection.V2.Data.Tv_App",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Stubs.Reflection.V2.Data.aqualv",
"FStar.Stubs.Reflection.V2.Data.Q_Explicit",
"FStar.Stubs.Reflection.V2.Data.Tv_Match",
"FStar.Pervasives.Native.None",
"FStar.Stubs.Reflection.Types.match_returns_ascription",
"Prims.Cons",
"FStar.Stubs.Reflection.V2.Data.branch",
"FStar.Stubs.Reflection.V2.Data.pattern",
"FStar.Stubs.Reflection.V2.Data.Pat_Constant",
"Prims.Nil"
] | [
"mutual recursion"
] | false | false | false | true | false | let rec elab_exp (e: src_exp) : Tot R.term =
| let open R in
match e with
| EBool true -> pack_ln (Tv_Const R.C_True)
| EBool false -> pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)]) | false |
Vale.Arch.Heap.fst | Vale.Arch.Heap.one_heaplet | val one_heaplet (ih: interop_heap) (id: option heaplet_id) : GTot vale_heap | val one_heaplet (ih: interop_heap) (id: option heaplet_id) : GTot vale_heap | let one_heaplet (ih:interop_heap) (id:option heaplet_id) : GTot vale_heap =
let m = down_mem ih in
let g = Ghost.hide ih in
ValeHeap m g id | {
"file_name": "vale/code/arch/Vale.Arch.Heap.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 17,
"end_line": 37,
"start_col": 0,
"start_line": 34
} | module Vale.Arch.Heap
open FStar.Mul
open Vale.Interop
open Vale.Arch.HeapImpl
module Map16 = Vale.Lib.Map16
friend Vale.Arch.HeapImpl
let heap_impl = vale_full_heap
let heap_get hi = hi.vf_heap.mh
let heap_taint hi = hi.vf_layout.vl_taint
// Update heaplet k with mh', but only for the addresses that k owns (addresses not owned by k remain unmodified)
let heaplet_upd_f (vfh:vale_full_heap) (mh':machine_heap) (k:heaplet_id) : vale_heap =
let hk = Map16.sel vfh.vf_heaplets k in
let mhk = hk.mh in
let dom_upd = Set.intersect (vfh.vf_layout.vl_inner.vl_heaplet_sets k) (Map.domain mhk) in
let mhk' = Map.concat mhk (Map.restrict dom_upd mh') in
mi_heap_upd hk mhk'
let heap_upd hi mh' mt' =
let h' = mi_heap_upd hi.vf_heap mh' in
let hs' = Map16.init vale_heap (heaplet_upd_f hi mh') in
{
vf_layout = {hi.vf_layout with vl_taint = mt'};
vf_heap = h';
vf_heaplets = hs';
}
let heap_create_machine ih =
down_mem ih | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Map16.fsti.checked",
"Vale.Interop.fsti.checked",
"Vale.Arch.HeapImpl.fst.checked",
"Vale.Arch.HeapImpl.fst.checked",
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Arch.Heap.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Heap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
ih: Vale.Interop.Heap_s.interop_heap ->
id: FStar.Pervasives.Native.option Vale.Arch.HeapImpl.heaplet_id
-> Prims.GTot Vale.Arch.HeapImpl.vale_heap | Prims.GTot | [
"sometrivial"
] | [] | [
"Vale.Interop.Heap_s.interop_heap",
"FStar.Pervasives.Native.option",
"Vale.Arch.HeapImpl.heaplet_id",
"Vale.Arch.HeapImpl.ValeHeap",
"FStar.Ghost.erased",
"FStar.Ghost.hide",
"Vale.Arch.MachineHeap_s.machine_heap",
"Vale.Interop.Heap_s.correct_down",
"Vale.Interop.down_mem",
"Vale.Arch.HeapImpl.vale_heap"
] | [] | false | false | false | false | false | let one_heaplet (ih: interop_heap) (id: option heaplet_id) : GTot vale_heap =
| let m = down_mem ih in
let g = Ghost.hide ih in
ValeHeap m g id | false |
DependentBoolRefinement.fst | DependentBoolRefinement.ok | val ok : sg: DependentBoolRefinement.src_env -> e: DependentBoolRefinement.src_exp -> Prims.logical | let ok (sg:src_env) (e:src_exp) = (forall x. x `Set.mem` freevars e ==> Some? (lookup sg x)) | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 92,
"end_line": 452,
"start_col": 0,
"start_line": 452
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1
let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1
let check_sub_typing f
(sg:src_env)
(t0 t1:src_ty)
: T.Tac (sub_typing f sg t0 t1)
= if t0 = t1 then S_Refl _ t0
else T.fail "Not subtypes"
let weaken (f:fstar_top_env) (sg:src_env) (hyp:var { None? (lookup sg hyp) } ) (b:src_exp) (t0 t1:src_ty)
: T.Tac (t:src_ty &
sub_typing f ((hyp,Inr(b, EBool true))::sg) t0 t &
sub_typing f ((hyp,Inr(b, EBool false))::sg) t1 t)
= if t0 = t1
then (| t0, S_Refl _ t0, S_Refl _ t1 |)
else T.fail "weaken is very dumb" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | sg: DependentBoolRefinement.src_env -> e: DependentBoolRefinement.src_exp -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"DependentBoolRefinement.src_env",
"DependentBoolRefinement.src_exp",
"Prims.l_Forall",
"DependentBoolRefinement.var",
"Prims.l_imp",
"Prims.b2t",
"FStar.Set.mem",
"DependentBoolRefinement.freevars",
"FStar.Pervasives.Native.uu___is_Some",
"DependentBoolRefinement.binding",
"DependentBoolRefinement.lookup",
"Prims.logical"
] | [] | false | false | false | true | true | let ok (sg: src_env) (e: src_exp) =
| (forall x. x `Set.mem` (freevars e) ==> Some? (lookup sg x)) | false |
|
DependentBoolRefinement.fst | DependentBoolRefinement.elab_ty | val elab_ty (t: src_ty) : R.term | val elab_ty (t: src_ty) : R.term | let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement) | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 40,
"end_line": 273,
"start_col": 0,
"start_line": 219
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | t: DependentBoolRefinement.src_ty -> FStar.Stubs.Reflection.Types.term | Prims.Tot | [
"total"
] | [
"elab_exp",
"elab_ty"
] | [
"DependentBoolRefinement.src_ty",
"FStar.Reflection.Typing.bool_ty",
"FStar.Stubs.Reflection.V2.Builtins.pack_ln",
"FStar.Stubs.Reflection.V2.Data.Tv_Arrow",
"FStar.Reflection.Typing.mk_simple_binder",
"FStar.Reflection.Typing.pp_name_default",
"FStar.Reflection.Typing.mk_total",
"FStar.Stubs.Reflection.Types.term",
"DependentBoolRefinement.elab_ty",
"DependentBoolRefinement.src_exp",
"FStar.Stubs.Reflection.V2.Data.Tv_Refine",
"DependentBoolRefinement.r_b2t",
"FStar.Stubs.Reflection.Types.bv",
"FStar.Stubs.Reflection.V2.Builtins.pack_bv",
"FStar.Reflection.Typing.make_bv",
"FStar.Stubs.Reflection.V2.Data.simple_binder",
"DependentBoolRefinement.elab_exp"
] | [
"mutual recursion"
] | false | false | false | true | false | let rec elab_ty (t: src_ty) : R.term =
| let open R in
match t with
| TBool -> RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln (R.Tv_Arrow (RT.mk_simple_binder RT.pp_name_default t1) (RT.mk_total t2))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement) | false |
DependentBoolRefinement.fst | DependentBoolRefinement.weaken | val weaken
(f: fstar_top_env)
(sg: src_env)
(hyp: var{None? (lookup sg hyp)})
(b: src_exp)
(t0 t1: src_ty)
: T.Tac
(t: src_ty &
sub_typing f ((hyp, Inr (b, EBool true)) :: sg) t0 t &
sub_typing f ((hyp, Inr (b, EBool false)) :: sg) t1 t) | val weaken
(f: fstar_top_env)
(sg: src_env)
(hyp: var{None? (lookup sg hyp)})
(b: src_exp)
(t0 t1: src_ty)
: T.Tac
(t: src_ty &
sub_typing f ((hyp, Inr (b, EBool true)) :: sg) t0 t &
sub_typing f ((hyp, Inr (b, EBool false)) :: sg) t1 t) | let weaken (f:fstar_top_env) (sg:src_env) (hyp:var { None? (lookup sg hyp) } ) (b:src_exp) (t0 t1:src_ty)
: T.Tac (t:src_ty &
sub_typing f ((hyp,Inr(b, EBool true))::sg) t0 t &
sub_typing f ((hyp,Inr(b, EBool false))::sg) t1 t)
= if t0 = t1
then (| t0, S_Refl _ t0, S_Refl _ t1 |)
else T.fail "weaken is very dumb" | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 37,
"end_line": 450,
"start_col": 0,
"start_line": 444
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1
let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1
let check_sub_typing f
(sg:src_env)
(t0 t1:src_ty)
: T.Tac (sub_typing f sg t0 t1)
= if t0 = t1 then S_Refl _ t0
else T.fail "Not subtypes" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
f: DependentBoolRefinement.fstar_top_env ->
sg: DependentBoolRefinement.src_env ->
hyp: DependentBoolRefinement.var{None? (DependentBoolRefinement.lookup sg hyp)} ->
b: DependentBoolRefinement.src_exp ->
t0: DependentBoolRefinement.src_ty ->
t1: DependentBoolRefinement.src_ty
-> FStar.Tactics.Effect.Tac
(FStar.Pervasives.dtuple3 DependentBoolRefinement.src_ty
(fun t ->
DependentBoolRefinement.sub_typing f
((hyp, FStar.Pervasives.Inr (b, DependentBoolRefinement.EBool true)) :: sg)
t0
t)
(fun t _ ->
DependentBoolRefinement.sub_typing f
((hyp, FStar.Pervasives.Inr (b, DependentBoolRefinement.EBool false)) :: sg)
t1
t)) | FStar.Tactics.Effect.Tac | [] | [] | [
"DependentBoolRefinement.fstar_top_env",
"DependentBoolRefinement.src_env",
"DependentBoolRefinement.var",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_None",
"DependentBoolRefinement.binding",
"DependentBoolRefinement.lookup",
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.src_ty",
"Prims.op_Equality",
"FStar.Pervasives.Mkdtuple3",
"DependentBoolRefinement.sub_typing",
"Prims.Cons",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Inr",
"DependentBoolRefinement.src_eqn",
"DependentBoolRefinement.EBool",
"DependentBoolRefinement.S_Refl",
"FStar.Pervasives.dtuple3",
"Prims.bool",
"FStar.Tactics.V2.Derived.fail"
] | [] | false | true | false | false | false | let weaken
(f: fstar_top_env)
(sg: src_env)
(hyp: var{None? (lookup sg hyp)})
(b: src_exp)
(t0 t1: src_ty)
: T.Tac
(t: src_ty &
sub_typing f ((hyp, Inr (b, EBool true)) :: sg) t0 t &
sub_typing f ((hyp, Inr (b, EBool false)) :: sg) t1 t) =
| if t0 = t1 then (| t0, S_Refl _ t0, S_Refl _ t1 |) else T.fail "weaken is very dumb" | false |
DependentBoolRefinement.fst | DependentBoolRefinement.check_sub_typing | val check_sub_typing (f: _) (sg: src_env) (t0 t1: src_ty) : T.Tac (sub_typing f sg t0 t1) | val check_sub_typing (f: _) (sg: src_env) (t0 t1: src_ty) : T.Tac (sub_typing f sg t0 t1) | let check_sub_typing f
(sg:src_env)
(t0 t1:src_ty)
: T.Tac (sub_typing f sg t0 t1)
= if t0 = t1 then S_Refl _ t0
else T.fail "Not subtypes" | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 30,
"end_line": 442,
"start_col": 0,
"start_line": 437
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1
let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
f: DependentBoolRefinement.fstar_top_env ->
sg: DependentBoolRefinement.src_env ->
t0: DependentBoolRefinement.src_ty ->
t1: DependentBoolRefinement.src_ty
-> FStar.Tactics.Effect.Tac (DependentBoolRefinement.sub_typing f sg t0 t1) | FStar.Tactics.Effect.Tac | [] | [] | [
"DependentBoolRefinement.fstar_top_env",
"DependentBoolRefinement.src_env",
"DependentBoolRefinement.src_ty",
"Prims.op_Equality",
"DependentBoolRefinement.S_Refl",
"DependentBoolRefinement.sub_typing",
"Prims.bool",
"FStar.Tactics.V2.Derived.fail"
] | [] | false | true | false | false | false | let check_sub_typing f (sg: src_env) (t0: src_ty) (t1: src_ty) : T.Tac (sub_typing f sg t0 t1) =
| if t0 = t1 then S_Refl _ t0 else T.fail "Not subtypes" | false |
DependentBoolRefinement.fst | DependentBoolRefinement.t_height | val t_height (#f: _) (#g: src_env) (#t: src_ty) (d: src_ty_ok f g t) : GTot nat (decreases d) | val t_height (#f: _) (#g: src_env) (#t: src_ty) (d: src_ty_ok f g t) : GTot nat (decreases d) | let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1 | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 40,
"end_line": 435,
"start_col": 0,
"start_line": 418
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | d: DependentBoolRefinement.src_ty_ok f g t -> Prims.GTot Prims.nat | Prims.GTot | [
"sometrivial",
""
] | [
"height",
"t_height"
] | [
"DependentBoolRefinement.fstar_top_env",
"DependentBoolRefinement.src_env",
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.src_ty_ok",
"DependentBoolRefinement.var",
"Prims.l_and",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_None",
"DependentBoolRefinement.binding",
"DependentBoolRefinement.lookup",
"Prims.l_not",
"FStar.Set.mem",
"DependentBoolRefinement.freevars_ty",
"Prims.Cons",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Inl",
"DependentBoolRefinement.src_eqn",
"DependentBoolRefinement.open_ty",
"Prims.op_Addition",
"DependentBoolRefinement.max",
"DependentBoolRefinement.t_height",
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.freevars",
"DependentBoolRefinement.src_typing",
"DependentBoolRefinement.TBool",
"DependentBoolRefinement.open_exp",
"DependentBoolRefinement.height",
"Prims.nat"
] | [
"mutual recursion"
] | false | false | false | false | false | let rec t_height #f (#g: src_env) (#t: src_ty) (d: src_ty_ok f g t) : GTot nat (decreases d) =
| match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1 | false |
DependentBoolRefinement.fst | DependentBoolRefinement.check_ok | val check_ok (e: src_exp) (sg: src_env) : b: bool{b <==> ok sg e} | val check_ok (e: src_exp) (sg: src_env) : b: bool{b <==> ok sg e} | let rec check_ok_ty (t:src_ty) (sg:src_env)
: b:bool { b <==> (ok_ty sg t) }
= match t with
| TBool -> true
| TArrow t1 t2 ->
check_ok_ty t1 sg &&
check_ok_ty t2 sg
| TRefineBool e ->
check_ok e sg
and check_ok (e:src_exp) (sg:src_env)
: b:bool { b <==> ok sg e }
= match e with
| EBVar _ -> true
| EVar x -> Some? (lookup sg x)
| EBool _ -> true
| EIf b e1 e2 -> check_ok b sg && check_ok e1 sg && check_ok e2 sg
| ELam t e -> check_ok_ty t sg && check_ok e sg
| EApp e1 e2 -> check_ok e1 sg && check_ok e2 sg | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 52,
"end_line": 472,
"start_col": 0,
"start_line": 455
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1
let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1
let check_sub_typing f
(sg:src_env)
(t0 t1:src_ty)
: T.Tac (sub_typing f sg t0 t1)
= if t0 = t1 then S_Refl _ t0
else T.fail "Not subtypes"
let weaken (f:fstar_top_env) (sg:src_env) (hyp:var { None? (lookup sg hyp) } ) (b:src_exp) (t0 t1:src_ty)
: T.Tac (t:src_ty &
sub_typing f ((hyp,Inr(b, EBool true))::sg) t0 t &
sub_typing f ((hyp,Inr(b, EBool false))::sg) t1 t)
= if t0 = t1
then (| t0, S_Refl _ t0, S_Refl _ t1 |)
else T.fail "weaken is very dumb"
let ok (sg:src_env) (e:src_exp) = (forall x. x `Set.mem` freevars e ==> Some? (lookup sg x))
let ok_ty (sg:src_env) (e:src_ty) = (forall x. x `Set.mem` freevars_ty e ==> Some? (lookup sg x)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | e: DependentBoolRefinement.src_exp -> sg: DependentBoolRefinement.src_env
-> b: Prims.bool{b <==> DependentBoolRefinement.ok sg e} | Prims.Tot | [
"total"
] | [
"check_ok_ty",
"check_ok"
] | [
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.src_env",
"DependentBoolRefinement.index",
"DependentBoolRefinement.var",
"FStar.Pervasives.Native.uu___is_Some",
"DependentBoolRefinement.binding",
"DependentBoolRefinement.lookup",
"Prims.bool",
"Prims.op_AmpAmp",
"DependentBoolRefinement.check_ok",
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.check_ok_ty",
"Prims.l_iff",
"Prims.b2t",
"DependentBoolRefinement.ok"
] | [
"mutual recursion"
] | false | false | false | false | false | let rec check_ok (e: src_exp) (sg: src_env) : b: bool{b <==> ok sg e} =
| match e with
| EBVar _ -> true
| EVar x -> Some? (lookup sg x)
| EBool _ -> true
| EIf b e1 e2 -> check_ok b sg && check_ok e1 sg && check_ok e2 sg
| ELam t e -> check_ok_ty t sg && check_ok e sg
| EApp e1 e2 -> check_ok e1 sg && check_ok e2 sg | false |
DependentBoolRefinement.fst | DependentBoolRefinement.b2t_typing | val b2t_typing (g: fstar_env) (t: R.term) (dt: RT.tot_typing g t RT.bool_ty)
: RT.tot_typing g (r_b2t t) (RT.tm_type RT.u_zero) | val b2t_typing (g: fstar_env) (t: R.term) (dt: RT.tot_typing g t RT.bool_ty)
: RT.tot_typing g (r_b2t t) (RT.tm_type RT.u_zero) | let b2t_typing (g:fstar_env) (t:R.term) (dt:RT.tot_typing g t RT.bool_ty)
: RT.tot_typing g (r_b2t t) (RT.tm_type RT.u_zero)
= let b2t_typing : RT.tot_typing g _ b2t_ty = RT.T_FVar g b2t_fv in
let app_ty : _ = RT.T_App _ _ _ _ (RT.tm_type RT.u_zero) _ b2t_typing dt in
RT.open_with_spec (RT.tm_type RT.u_zero) t;
app_ty | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 10,
"end_line": 629,
"start_col": 0,
"start_line": 624
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1
let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1
let check_sub_typing f
(sg:src_env)
(t0 t1:src_ty)
: T.Tac (sub_typing f sg t0 t1)
= if t0 = t1 then S_Refl _ t0
else T.fail "Not subtypes"
let weaken (f:fstar_top_env) (sg:src_env) (hyp:var { None? (lookup sg hyp) } ) (b:src_exp) (t0 t1:src_ty)
: T.Tac (t:src_ty &
sub_typing f ((hyp,Inr(b, EBool true))::sg) t0 t &
sub_typing f ((hyp,Inr(b, EBool false))::sg) t1 t)
= if t0 = t1
then (| t0, S_Refl _ t0, S_Refl _ t1 |)
else T.fail "weaken is very dumb"
let ok (sg:src_env) (e:src_exp) = (forall x. x `Set.mem` freevars e ==> Some? (lookup sg x))
let ok_ty (sg:src_env) (e:src_ty) = (forall x. x `Set.mem` freevars_ty e ==> Some? (lookup sg x))
let rec check_ok_ty (t:src_ty) (sg:src_env)
: b:bool { b <==> (ok_ty sg t) }
= match t with
| TBool -> true
| TArrow t1 t2 ->
check_ok_ty t1 sg &&
check_ok_ty t2 sg
| TRefineBool e ->
check_ok e sg
and check_ok (e:src_exp) (sg:src_env)
: b:bool { b <==> ok sg e }
= match e with
| EBVar _ -> true
| EVar x -> Some? (lookup sg x)
| EBool _ -> true
| EIf b e1 e2 -> check_ok b sg && check_ok e1 sg && check_ok e2 sg
| ELam t e -> check_ok_ty t sg && check_ok e sg
| EApp e1 e2 -> check_ok e1 sg && check_ok e2 sg
#push-options "--fuel 2 --ifuel 2 --z3rlimit_factor 6 --query_stats"
let rec check (f:fstar_top_env)
(sg:src_env)
(e:src_exp { ok sg e })
: T.Tac (t:src_ty &
src_typing f sg e t)
= match e with
| EBVar _ ->
T.fail "Not locally nameless"
| EBool b ->
(| TBool, T_Bool _ b |)
| EVar n ->
begin
match lookup_ty sg n with
| None -> T.fail "Ill-typed"
| Some t ->
let d = T_Var sg n in
(| t, d |)
end
| ELam t body ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars body (EVar x) 0;
let (| tbody, dbody |) = check f ((x, Inl t)::sg) (open_exp body x) in
let dd : src_typing f sg e (TArrow t (close_ty tbody x)) =
T_Lam sg t body tbody x t_ok dbody in
(| TArrow t (close_ty tbody x), dd |)
| EApp e1 e2 ->
let (| t1, d1 |) = check f sg e1 in
let (| t2, d2 |) = check f sg e2 in
begin
match t1 with
| TArrow t_arg t_res ->
let st_ok = check_sub_typing f sg t2 t_arg in
(| open_ty_with t_res e2, T_App _ _ _ t_arg t_res _ d1 d2 st_ok |)
| _ ->
T.fail "Expected a function"
end
| EIf b e1 e2 ->
let (| tb, ok_b |) = check f sg b in
let hyp = fresh sg in
fresh_is_fresh sg;
if tb = TBool
then (
let (| t1, ok_1 |) = check f ((hyp, Inr(b, EBool true))::sg) e1 in
let (| t2, ok_2 |) = check f ((hyp, Inr(b, EBool false))::sg) e2 in
let (| t, w1, w2 |) = weaken f sg hyp b t1 t2 in
if not (check_ok_ty t sg)
then T.fail "Free variable escapes scope"
else (
let t_ok = check_ty f sg t in
(| t, T_If _ _ _ _ _ _ _ hyp ok_b ok_1 ok_2 w1 w2 t_ok |)
)
)
else T.fail "Branching on a non-boolean"
and check_ty (f:fstar_top_env)
(sg:src_env)
(t:src_ty { ok_ty sg t })
: T.Tac (src_ty_ok f sg t)
= match t with
| TBool -> OK_TBool _
| TArrow t t' ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_ty_freevars t' (EVar x) 0;
let t'_ok = check_ty f ((x, Inl t)::sg) (open_ty t' x) in
OK_TArrow _ _ _ x t_ok t'_ok
| TRefineBool e ->
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars e (EVar x) 0;
let (| te, de |) = check f ((x, Inl TBool)::sg) (open_exp e x) in
match te with
| TBool -> OK_TRefine sg e x de
| _ -> T.fail "Ill-typed refinement"
#pop-options
let rec extend_env_l_lookup_bvar (g:R.env) (sg:src_env) (x:var)
: Lemma
(requires (forall x. RT.lookup_bvar g x == None))
(ensures (
match lookup sg x with
| Some b -> RT.lookup_bvar (extend_env_l g sg) x == Some (elab_binding b)
| None -> RT.lookup_bvar (extend_env_l g sg) x == None))
(decreases sg)
[SMTPat (RT.lookup_bvar (extend_env_l g sg) x)]
= match sg with
| [] -> ()
| hd :: tl -> extend_env_l_lookup_bvar g tl x
#push-options "--query_stats --fuel 8 --ifuel 2 --z3rlimit_factor 2"
let rec elab_open_commute' (n:nat) (e:src_exp) (x:src_exp)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.DT n (elab_exp x) ] ==
elab_exp (open_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| EIf b e1 e2 ->
elab_open_commute' n b x;
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| ELam t e ->
elab_ty_open_commute' n t x;
elab_open_commute' (n + 1) e x
and elab_ty_open_commute' (n:nat) (e:src_ty) (x:src_exp)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.DT n (elab_exp x) ] ==
elab_ty (open_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_open_commute' n t x;
elab_ty_open_commute' (n + 1) t' x
| TRefineBool e ->
elab_open_commute' (n + 1) e x
#pop-options
let elab_open_commute (e:src_exp) (x:var)
: Lemma (RT.open_term (elab_exp e) x == elab_exp (open_exp e x))
[SMTPat (RT.open_term (elab_exp e) x)]
= elab_open_commute' 0 e (EVar x);
RT.open_term_spec (elab_exp e) x | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
g: DependentBoolRefinement.fstar_env ->
t: FStar.Stubs.Reflection.Types.term ->
dt: FStar.Reflection.Typing.tot_typing g t FStar.Reflection.Typing.bool_ty
-> FStar.Reflection.Typing.tot_typing g
(DependentBoolRefinement.r_b2t t)
(FStar.Reflection.Typing.tm_type FStar.Reflection.Typing.u_zero) | Prims.Tot | [
"total"
] | [] | [
"DependentBoolRefinement.fstar_env",
"FStar.Stubs.Reflection.Types.term",
"FStar.Reflection.Typing.tot_typing",
"FStar.Reflection.Typing.bool_ty",
"Prims.unit",
"FStar.Reflection.Typing.open_with_spec",
"FStar.Reflection.Typing.tm_type",
"FStar.Reflection.Typing.u_zero",
"FStar.Reflection.Typing.typing",
"FStar.Stubs.Reflection.V2.Builtins.pack_ln",
"FStar.Stubs.Reflection.V2.Data.Tv_App",
"FStar.Stubs.Reflection.V2.Data.Tv_FVar",
"DependentBoolRefinement.b2t_fv",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Stubs.Reflection.V2.Data.aqualv",
"FStar.Reflection.Typing.binder_qual",
"FStar.Reflection.Typing.mk_simple_binder",
"FStar.Reflection.Typing.pp_name_default",
"FStar.Stubs.TypeChecker.Core.tot_or_ghost",
"FStar.Stubs.Reflection.Types.typ",
"FStar.Stubs.TypeChecker.Core.E_Total",
"FStar.Reflection.Typing.open_with",
"FStar.Reflection.Typing.T_App",
"DependentBoolRefinement.b2t_ty",
"FStar.Reflection.Typing.T_FVar",
"DependentBoolRefinement.r_b2t"
] | [] | false | false | false | false | false | let b2t_typing (g: fstar_env) (t: R.term) (dt: RT.tot_typing g t RT.bool_ty)
: RT.tot_typing g (r_b2t t) (RT.tm_type RT.u_zero) =
| let b2t_typing:RT.tot_typing g _ b2t_ty = RT.T_FVar g b2t_fv in
let app_ty:_ = RT.T_App _ _ _ _ (RT.tm_type RT.u_zero) _ b2t_typing dt in
RT.open_with_spec (RT.tm_type RT.u_zero) t;
app_ty | false |
Hacl.Spec.K256.Field52.Lemmas.fst | Hacl.Spec.K256.Field52.Lemmas.load_felem5_lemma | val load_felem5_lemma: s:felem4 ->
Lemma (let f = load_felem5 s in
felem_fits5 f (1,1,1,1,1) /\ as_nat5 f == as_nat4 s) | val load_felem5_lemma: s:felem4 ->
Lemma (let f = load_felem5 s in
felem_fits5 f (1,1,1,1,1) /\ as_nat5 f == as_nat4 s) | let load_felem5_lemma s =
L1.load_felem5_lemma s | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 24,
"end_line": 20,
"start_col": 0,
"start_line": 19
} | module Hacl.Spec.K256.Field52.Lemmas
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
include Hacl.Spec.K256.Field52.Definitions
include Hacl.Spec.K256.Field52
module ML = Hacl.Spec.K256.MathLemmas
module LD = Hacl.Spec.K256.Field52.Definitions.Lemmas
module L1 = Hacl.Spec.K256.Field52.Lemmas1
module L2 = Hacl.Spec.K256.Field52.Lemmas2
module L3 = Hacl.Spec.K256.Field52.Lemmas3
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0" | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.K256.MathLemmas.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas3.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas2.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas1.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.Lemmas.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.fst.checked",
"Hacl.Spec.K256.Field52.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.K256.Field52.Lemmas.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas3",
"short_module": "L3"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas2",
"short_module": "L2"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas1",
"short_module": "L1"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Definitions.Lemmas",
"short_module": "LD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.MathLemmas",
"short_module": "ML"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s: Hacl.Spec.K256.Field52.Definitions.felem4
-> FStar.Pervasives.Lemma
(ensures
(let f = Hacl.Spec.K256.Field52.load_felem5 s in
Hacl.Spec.K256.Field52.Definitions.felem_fits5 f (1, 1, 1, 1, 1) /\
Hacl.Spec.K256.Field52.Definitions.as_nat5 f == Hacl.Spec.K256.Field52.Definitions.as_nat4 s
)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.K256.Field52.Definitions.felem4",
"Hacl.Spec.K256.Field52.Lemmas1.load_felem5_lemma",
"Prims.unit"
] | [] | true | false | true | false | false | let load_felem5_lemma s =
| L1.load_felem5_lemma s | false |
DependentBoolRefinement.fst | DependentBoolRefinement.ok_ty | val ok_ty : sg: DependentBoolRefinement.src_env -> e: DependentBoolRefinement.src_ty -> Prims.logical | let ok_ty (sg:src_env) (e:src_ty) = (forall x. x `Set.mem` freevars_ty e ==> Some? (lookup sg x)) | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 97,
"end_line": 453,
"start_col": 0,
"start_line": 453
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1
let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1
let check_sub_typing f
(sg:src_env)
(t0 t1:src_ty)
: T.Tac (sub_typing f sg t0 t1)
= if t0 = t1 then S_Refl _ t0
else T.fail "Not subtypes"
let weaken (f:fstar_top_env) (sg:src_env) (hyp:var { None? (lookup sg hyp) } ) (b:src_exp) (t0 t1:src_ty)
: T.Tac (t:src_ty &
sub_typing f ((hyp,Inr(b, EBool true))::sg) t0 t &
sub_typing f ((hyp,Inr(b, EBool false))::sg) t1 t)
= if t0 = t1
then (| t0, S_Refl _ t0, S_Refl _ t1 |)
else T.fail "weaken is very dumb" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | sg: DependentBoolRefinement.src_env -> e: DependentBoolRefinement.src_ty -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"DependentBoolRefinement.src_env",
"DependentBoolRefinement.src_ty",
"Prims.l_Forall",
"DependentBoolRefinement.var",
"Prims.l_imp",
"Prims.b2t",
"FStar.Set.mem",
"DependentBoolRefinement.freevars_ty",
"FStar.Pervasives.Native.uu___is_Some",
"DependentBoolRefinement.binding",
"DependentBoolRefinement.lookup",
"Prims.logical"
] | [] | false | false | false | true | true | let ok_ty (sg: src_env) (e: src_ty) =
| (forall x. x `Set.mem` (freevars_ty e) ==> Some? (lookup sg x)) | false |
|
DependentBoolRefinement.fst | DependentBoolRefinement.subtyping_soundness | val subtyping_soundness (#f: _) (#sg: src_env) (#t0 #t1: src_ty) (ds: sub_typing f sg t0 t1)
: GTot (RT.sub_typing (extend_env_l f sg) (elab_ty t0) (elab_ty t1)) | val subtyping_soundness (#f: _) (#sg: src_env) (#t0 #t1: src_ty) (ds: sub_typing f sg t0 t1)
: GTot (RT.sub_typing (extend_env_l f sg) (elab_ty t0) (elab_ty t1)) | let subtyping_soundness #f (#sg:src_env) (#t0 #t1:src_ty) (ds:sub_typing f sg t0 t1)
: GTot (RT.sub_typing (extend_env_l f sg) (elab_ty t0) (elab_ty t1))
= match ds with
| S_Refl _ _ -> RT.Rel_equiv _ _ _ _ (RT.Rel_refl _ _ _)
| S_ELab _ _ _ d -> d | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 25,
"end_line": 647,
"start_col": 0,
"start_line": 643
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1
let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1
let check_sub_typing f
(sg:src_env)
(t0 t1:src_ty)
: T.Tac (sub_typing f sg t0 t1)
= if t0 = t1 then S_Refl _ t0
else T.fail "Not subtypes"
let weaken (f:fstar_top_env) (sg:src_env) (hyp:var { None? (lookup sg hyp) } ) (b:src_exp) (t0 t1:src_ty)
: T.Tac (t:src_ty &
sub_typing f ((hyp,Inr(b, EBool true))::sg) t0 t &
sub_typing f ((hyp,Inr(b, EBool false))::sg) t1 t)
= if t0 = t1
then (| t0, S_Refl _ t0, S_Refl _ t1 |)
else T.fail "weaken is very dumb"
let ok (sg:src_env) (e:src_exp) = (forall x. x `Set.mem` freevars e ==> Some? (lookup sg x))
let ok_ty (sg:src_env) (e:src_ty) = (forall x. x `Set.mem` freevars_ty e ==> Some? (lookup sg x))
let rec check_ok_ty (t:src_ty) (sg:src_env)
: b:bool { b <==> (ok_ty sg t) }
= match t with
| TBool -> true
| TArrow t1 t2 ->
check_ok_ty t1 sg &&
check_ok_ty t2 sg
| TRefineBool e ->
check_ok e sg
and check_ok (e:src_exp) (sg:src_env)
: b:bool { b <==> ok sg e }
= match e with
| EBVar _ -> true
| EVar x -> Some? (lookup sg x)
| EBool _ -> true
| EIf b e1 e2 -> check_ok b sg && check_ok e1 sg && check_ok e2 sg
| ELam t e -> check_ok_ty t sg && check_ok e sg
| EApp e1 e2 -> check_ok e1 sg && check_ok e2 sg
#push-options "--fuel 2 --ifuel 2 --z3rlimit_factor 6 --query_stats"
let rec check (f:fstar_top_env)
(sg:src_env)
(e:src_exp { ok sg e })
: T.Tac (t:src_ty &
src_typing f sg e t)
= match e with
| EBVar _ ->
T.fail "Not locally nameless"
| EBool b ->
(| TBool, T_Bool _ b |)
| EVar n ->
begin
match lookup_ty sg n with
| None -> T.fail "Ill-typed"
| Some t ->
let d = T_Var sg n in
(| t, d |)
end
| ELam t body ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars body (EVar x) 0;
let (| tbody, dbody |) = check f ((x, Inl t)::sg) (open_exp body x) in
let dd : src_typing f sg e (TArrow t (close_ty tbody x)) =
T_Lam sg t body tbody x t_ok dbody in
(| TArrow t (close_ty tbody x), dd |)
| EApp e1 e2 ->
let (| t1, d1 |) = check f sg e1 in
let (| t2, d2 |) = check f sg e2 in
begin
match t1 with
| TArrow t_arg t_res ->
let st_ok = check_sub_typing f sg t2 t_arg in
(| open_ty_with t_res e2, T_App _ _ _ t_arg t_res _ d1 d2 st_ok |)
| _ ->
T.fail "Expected a function"
end
| EIf b e1 e2 ->
let (| tb, ok_b |) = check f sg b in
let hyp = fresh sg in
fresh_is_fresh sg;
if tb = TBool
then (
let (| t1, ok_1 |) = check f ((hyp, Inr(b, EBool true))::sg) e1 in
let (| t2, ok_2 |) = check f ((hyp, Inr(b, EBool false))::sg) e2 in
let (| t, w1, w2 |) = weaken f sg hyp b t1 t2 in
if not (check_ok_ty t sg)
then T.fail "Free variable escapes scope"
else (
let t_ok = check_ty f sg t in
(| t, T_If _ _ _ _ _ _ _ hyp ok_b ok_1 ok_2 w1 w2 t_ok |)
)
)
else T.fail "Branching on a non-boolean"
and check_ty (f:fstar_top_env)
(sg:src_env)
(t:src_ty { ok_ty sg t })
: T.Tac (src_ty_ok f sg t)
= match t with
| TBool -> OK_TBool _
| TArrow t t' ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_ty_freevars t' (EVar x) 0;
let t'_ok = check_ty f ((x, Inl t)::sg) (open_ty t' x) in
OK_TArrow _ _ _ x t_ok t'_ok
| TRefineBool e ->
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars e (EVar x) 0;
let (| te, de |) = check f ((x, Inl TBool)::sg) (open_exp e x) in
match te with
| TBool -> OK_TRefine sg e x de
| _ -> T.fail "Ill-typed refinement"
#pop-options
let rec extend_env_l_lookup_bvar (g:R.env) (sg:src_env) (x:var)
: Lemma
(requires (forall x. RT.lookup_bvar g x == None))
(ensures (
match lookup sg x with
| Some b -> RT.lookup_bvar (extend_env_l g sg) x == Some (elab_binding b)
| None -> RT.lookup_bvar (extend_env_l g sg) x == None))
(decreases sg)
[SMTPat (RT.lookup_bvar (extend_env_l g sg) x)]
= match sg with
| [] -> ()
| hd :: tl -> extend_env_l_lookup_bvar g tl x
#push-options "--query_stats --fuel 8 --ifuel 2 --z3rlimit_factor 2"
let rec elab_open_commute' (n:nat) (e:src_exp) (x:src_exp)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.DT n (elab_exp x) ] ==
elab_exp (open_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| EIf b e1 e2 ->
elab_open_commute' n b x;
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| ELam t e ->
elab_ty_open_commute' n t x;
elab_open_commute' (n + 1) e x
and elab_ty_open_commute' (n:nat) (e:src_ty) (x:src_exp)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.DT n (elab_exp x) ] ==
elab_ty (open_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_open_commute' n t x;
elab_ty_open_commute' (n + 1) t' x
| TRefineBool e ->
elab_open_commute' (n + 1) e x
#pop-options
let elab_open_commute (e:src_exp) (x:var)
: Lemma (RT.open_term (elab_exp e) x == elab_exp (open_exp e x))
[SMTPat (RT.open_term (elab_exp e) x)]
= elab_open_commute' 0 e (EVar x);
RT.open_term_spec (elab_exp e) x
let b2t_typing (g:fstar_env) (t:R.term) (dt:RT.tot_typing g t RT.bool_ty)
: RT.tot_typing g (r_b2t t) (RT.tm_type RT.u_zero)
= let b2t_typing : RT.tot_typing g _ b2t_ty = RT.T_FVar g b2t_fv in
let app_ty : _ = RT.T_App _ _ _ _ (RT.tm_type RT.u_zero) _ b2t_typing dt in
RT.open_with_spec (RT.tm_type RT.u_zero) t;
app_ty
let rec extend_env_l_lookup_fvar (g:R.env) (sg:src_env) (fv:R.fv)
: Lemma
(ensures
RT.lookup_fvar (extend_env_l g sg) fv ==
RT.lookup_fvar g fv)
[SMTPat (RT.lookup_fvar (extend_env_l g sg) fv)]
= match sg with
| [] -> ()
| hd::tl -> extend_env_l_lookup_fvar g tl fv
#push-options "--query_stats --fuel 2 --ifuel 2 --z3rlimit_factor 2" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 2,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 2,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | ds: DependentBoolRefinement.sub_typing f sg t0 t1
-> Prims.GTot
(FStar.Reflection.Typing.sub_typing (DependentBoolRefinement.extend_env_l f sg)
(DependentBoolRefinement.elab_ty t0)
(DependentBoolRefinement.elab_ty t1)) | Prims.GTot | [
"sometrivial"
] | [] | [
"DependentBoolRefinement.fstar_top_env",
"DependentBoolRefinement.src_env",
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.sub_typing",
"FStar.Reflection.Typing.Rel_equiv",
"DependentBoolRefinement.extend_env_l",
"DependentBoolRefinement.elab_ty",
"FStar.Reflection.Typing.R_Sub",
"FStar.Reflection.Typing.Rel_refl",
"FStar.Reflection.Typing.R_Eq",
"FStar.Reflection.Typing.sub_typing"
] | [] | false | false | false | false | false | let subtyping_soundness #f (#sg: src_env) (#t0: src_ty) (#t1: src_ty) (ds: sub_typing f sg t0 t1)
: GTot (RT.sub_typing (extend_env_l f sg) (elab_ty t0) (elab_ty t1)) =
| match ds with
| S_Refl _ _ -> RT.Rel_equiv _ _ _ _ (RT.Rel_refl _ _ _)
| S_ELab _ _ _ d -> d | false |
DependentBoolRefinement.fst | DependentBoolRefinement.height | val height (#f #g #e #t: _) (d: src_typing f g e t) : GTot nat (decreases d) | val height (#f #g #e #t: _) (d: src_typing f g e t) : GTot nat (decreases d) | let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1 | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 40,
"end_line": 435,
"start_col": 0,
"start_line": 418
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | d: DependentBoolRefinement.src_typing f g e t -> Prims.GTot Prims.nat | Prims.GTot | [
"sometrivial",
""
] | [
"height",
"t_height"
] | [
"DependentBoolRefinement.fstar_top_env",
"DependentBoolRefinement.src_env",
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.src_typing",
"Prims.bool",
"DependentBoolRefinement.var",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"DependentBoolRefinement.lookup_ty",
"Prims.l_and",
"FStar.Pervasives.Native.uu___is_None",
"DependentBoolRefinement.binding",
"DependentBoolRefinement.lookup",
"Prims.l_not",
"FStar.Set.mem",
"DependentBoolRefinement.freevars",
"DependentBoolRefinement.src_ty_ok",
"Prims.Cons",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Inl",
"DependentBoolRefinement.src_eqn",
"DependentBoolRefinement.open_exp",
"Prims.op_Addition",
"DependentBoolRefinement.max",
"DependentBoolRefinement.height",
"DependentBoolRefinement.t_height",
"DependentBoolRefinement.TArrow",
"DependentBoolRefinement.sub_typing",
"DependentBoolRefinement.s_height",
"DependentBoolRefinement.TBool",
"FStar.Pervasives.Inr",
"DependentBoolRefinement.EBool",
"Prims.nat"
] | [
"mutual recursion"
] | false | false | false | false | false | let rec height #f #g #e #t (d: src_typing f g e t) : GTot nat (decreases d) =
| match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr)) (max (s_height sl) (max (s_height sr) (t_height st)))) +
1 | false |
Hacl.Spec.K256.Field52.Lemmas.fst | Hacl.Spec.K256.Field52.Lemmas.store_felem5_lemma | val store_felem5_lemma: f:felem5 -> Lemma
(requires felem_fits5 f (1,1,1,1,1))
(ensures as_nat4 (store_felem5 f) == as_nat5 f) | val store_felem5_lemma: f:felem5 -> Lemma
(requires felem_fits5 f (1,1,1,1,1))
(ensures as_nat4 (store_felem5 f) == as_nat5 f) | let store_felem5_lemma f =
L1.store_felem5_lemma f | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 25,
"end_line": 24,
"start_col": 0,
"start_line": 23
} | module Hacl.Spec.K256.Field52.Lemmas
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
include Hacl.Spec.K256.Field52.Definitions
include Hacl.Spec.K256.Field52
module ML = Hacl.Spec.K256.MathLemmas
module LD = Hacl.Spec.K256.Field52.Definitions.Lemmas
module L1 = Hacl.Spec.K256.Field52.Lemmas1
module L2 = Hacl.Spec.K256.Field52.Lemmas2
module L3 = Hacl.Spec.K256.Field52.Lemmas3
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let load_felem5_lemma s =
L1.load_felem5_lemma s | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.K256.MathLemmas.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas3.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas2.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas1.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.Lemmas.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.fst.checked",
"Hacl.Spec.K256.Field52.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.K256.Field52.Lemmas.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas3",
"short_module": "L3"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas2",
"short_module": "L2"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas1",
"short_module": "L1"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Definitions.Lemmas",
"short_module": "LD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.MathLemmas",
"short_module": "ML"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | f: Hacl.Spec.K256.Field52.Definitions.felem5
-> FStar.Pervasives.Lemma
(requires Hacl.Spec.K256.Field52.Definitions.felem_fits5 f (1, 1, 1, 1, 1))
(ensures
Hacl.Spec.K256.Field52.Definitions.as_nat4 (Hacl.Spec.K256.Field52.store_felem5 f) ==
Hacl.Spec.K256.Field52.Definitions.as_nat5 f) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.K256.Field52.Definitions.felem5",
"Hacl.Spec.K256.Field52.Lemmas1.store_felem5_lemma",
"Prims.unit"
] | [] | true | false | true | false | false | let store_felem5_lemma f =
| L1.store_felem5_lemma f | false |
Vale.Arch.Heap.fst | Vale.Arch.Heap.heaplet_upd_f | val heaplet_upd_f (vfh: vale_full_heap) (mh': machine_heap) (k: heaplet_id) : vale_heap | val heaplet_upd_f (vfh: vale_full_heap) (mh': machine_heap) (k: heaplet_id) : vale_heap | let heaplet_upd_f (vfh:vale_full_heap) (mh':machine_heap) (k:heaplet_id) : vale_heap =
let hk = Map16.sel vfh.vf_heaplets k in
let mhk = hk.mh in
let dom_upd = Set.intersect (vfh.vf_layout.vl_inner.vl_heaplet_sets k) (Map.domain mhk) in
let mhk' = Map.concat mhk (Map.restrict dom_upd mh') in
mi_heap_upd hk mhk' | {
"file_name": "vale/code/arch/Vale.Arch.Heap.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 21,
"end_line": 20,
"start_col": 0,
"start_line": 15
} | module Vale.Arch.Heap
open FStar.Mul
open Vale.Interop
open Vale.Arch.HeapImpl
module Map16 = Vale.Lib.Map16
friend Vale.Arch.HeapImpl
let heap_impl = vale_full_heap
let heap_get hi = hi.vf_heap.mh
let heap_taint hi = hi.vf_layout.vl_taint | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Map16.fsti.checked",
"Vale.Interop.fsti.checked",
"Vale.Arch.HeapImpl.fst.checked",
"Vale.Arch.HeapImpl.fst.checked",
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Arch.Heap.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Heap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
vfh: Vale.Arch.HeapImpl.vale_full_heap ->
mh': Vale.Arch.MachineHeap_s.machine_heap ->
k: Vale.Arch.HeapImpl.heaplet_id
-> Vale.Arch.HeapImpl.vale_heap | Prims.Tot | [
"total"
] | [] | [
"Vale.Arch.HeapImpl.vale_full_heap",
"Vale.Arch.MachineHeap_s.machine_heap",
"Vale.Arch.HeapImpl.heaplet_id",
"Vale.Arch.HeapImpl.mi_heap_upd",
"FStar.Map.t",
"Prims.int",
"Vale.Def.Words_s.nat8",
"FStar.Map.concat",
"Vale.Def.Types_s.nat8",
"FStar.Map.restrict",
"FStar.Set.set",
"FStar.Set.intersect",
"Vale.Arch.HeapImpl.__proj__Mkvale_heap_layout_inner__item__vl_heaplet_sets",
"Vale.Arch.HeapImpl.__proj__Mkvale_heap_layout__item__vl_inner",
"Vale.Arch.HeapImpl.__proj__Mkvale_full_heap__item__vf_layout",
"FStar.Map.domain",
"Vale.Arch.HeapImpl.__proj__ValeHeap__item__mh",
"Vale.Arch.HeapImpl.vale_heap",
"Vale.Lib.Map16.sel",
"Vale.Arch.HeapImpl.__proj__Mkvale_full_heap__item__vf_heaplets"
] | [] | false | false | false | true | false | let heaplet_upd_f (vfh: vale_full_heap) (mh': machine_heap) (k: heaplet_id) : vale_heap =
| let hk = Map16.sel vfh.vf_heaplets k in
let mhk = hk.mh in
let dom_upd = Set.intersect (vfh.vf_layout.vl_inner.vl_heaplet_sets k) (Map.domain mhk) in
let mhk' = Map.concat mhk (Map.restrict dom_upd mh') in
mi_heap_upd hk mhk' | false |
Vale.Arch.Heap.fst | Vale.Arch.Heap.heap_create_machine | val heap_create_machine (ih:interop_heap) : Ghost machine_heap
(requires True)
(ensures fun mh -> correct_down ih mh) | val heap_create_machine (ih:interop_heap) : Ghost machine_heap
(requires True)
(ensures fun mh -> correct_down ih mh) | let heap_create_machine ih =
down_mem ih | {
"file_name": "vale/code/arch/Vale.Arch.Heap.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 13,
"end_line": 32,
"start_col": 0,
"start_line": 31
} | module Vale.Arch.Heap
open FStar.Mul
open Vale.Interop
open Vale.Arch.HeapImpl
module Map16 = Vale.Lib.Map16
friend Vale.Arch.HeapImpl
let heap_impl = vale_full_heap
let heap_get hi = hi.vf_heap.mh
let heap_taint hi = hi.vf_layout.vl_taint
// Update heaplet k with mh', but only for the addresses that k owns (addresses not owned by k remain unmodified)
let heaplet_upd_f (vfh:vale_full_heap) (mh':machine_heap) (k:heaplet_id) : vale_heap =
let hk = Map16.sel vfh.vf_heaplets k in
let mhk = hk.mh in
let dom_upd = Set.intersect (vfh.vf_layout.vl_inner.vl_heaplet_sets k) (Map.domain mhk) in
let mhk' = Map.concat mhk (Map.restrict dom_upd mh') in
mi_heap_upd hk mhk'
let heap_upd hi mh' mt' =
let h' = mi_heap_upd hi.vf_heap mh' in
let hs' = Map16.init vale_heap (heaplet_upd_f hi mh') in
{
vf_layout = {hi.vf_layout with vl_taint = mt'};
vf_heap = h';
vf_heaplets = hs';
} | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Map16.fsti.checked",
"Vale.Interop.fsti.checked",
"Vale.Arch.HeapImpl.fst.checked",
"Vale.Arch.HeapImpl.fst.checked",
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Arch.Heap.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Heap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | ih: Vale.Interop.Heap_s.interop_heap -> Prims.Ghost Vale.Arch.MachineHeap_s.machine_heap | Prims.Ghost | [] | [] | [
"Vale.Interop.Heap_s.interop_heap",
"Vale.Interop.down_mem",
"Vale.Arch.MachineHeap_s.machine_heap"
] | [] | false | false | false | false | false | let heap_create_machine ih =
| down_mem ih | false |
DependentBoolRefinement.fst | DependentBoolRefinement.extend_env_l_lookup_bvar | val extend_env_l_lookup_bvar (g: R.env) (sg: src_env) (x: var)
: Lemma (requires (forall x. RT.lookup_bvar g x == None))
(ensures
(match lookup sg x with
| Some b -> RT.lookup_bvar (extend_env_l g sg) x == Some (elab_binding b)
| None -> RT.lookup_bvar (extend_env_l g sg) x == None))
(decreases sg)
[SMTPat (RT.lookup_bvar (extend_env_l g sg) x)] | val extend_env_l_lookup_bvar (g: R.env) (sg: src_env) (x: var)
: Lemma (requires (forall x. RT.lookup_bvar g x == None))
(ensures
(match lookup sg x with
| Some b -> RT.lookup_bvar (extend_env_l g sg) x == Some (elab_binding b)
| None -> RT.lookup_bvar (extend_env_l g sg) x == None))
(decreases sg)
[SMTPat (RT.lookup_bvar (extend_env_l g sg) x)] | let rec extend_env_l_lookup_bvar (g:R.env) (sg:src_env) (x:var)
: Lemma
(requires (forall x. RT.lookup_bvar g x == None))
(ensures (
match lookup sg x with
| Some b -> RT.lookup_bvar (extend_env_l g sg) x == Some (elab_binding b)
| None -> RT.lookup_bvar (extend_env_l g sg) x == None))
(decreases sg)
[SMTPat (RT.lookup_bvar (extend_env_l g sg) x)]
= match sg with
| [] -> ()
| hd :: tl -> extend_env_l_lookup_bvar g tl x | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 49,
"end_line": 579,
"start_col": 0,
"start_line": 568
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1
let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1
let check_sub_typing f
(sg:src_env)
(t0 t1:src_ty)
: T.Tac (sub_typing f sg t0 t1)
= if t0 = t1 then S_Refl _ t0
else T.fail "Not subtypes"
let weaken (f:fstar_top_env) (sg:src_env) (hyp:var { None? (lookup sg hyp) } ) (b:src_exp) (t0 t1:src_ty)
: T.Tac (t:src_ty &
sub_typing f ((hyp,Inr(b, EBool true))::sg) t0 t &
sub_typing f ((hyp,Inr(b, EBool false))::sg) t1 t)
= if t0 = t1
then (| t0, S_Refl _ t0, S_Refl _ t1 |)
else T.fail "weaken is very dumb"
let ok (sg:src_env) (e:src_exp) = (forall x. x `Set.mem` freevars e ==> Some? (lookup sg x))
let ok_ty (sg:src_env) (e:src_ty) = (forall x. x `Set.mem` freevars_ty e ==> Some? (lookup sg x))
let rec check_ok_ty (t:src_ty) (sg:src_env)
: b:bool { b <==> (ok_ty sg t) }
= match t with
| TBool -> true
| TArrow t1 t2 ->
check_ok_ty t1 sg &&
check_ok_ty t2 sg
| TRefineBool e ->
check_ok e sg
and check_ok (e:src_exp) (sg:src_env)
: b:bool { b <==> ok sg e }
= match e with
| EBVar _ -> true
| EVar x -> Some? (lookup sg x)
| EBool _ -> true
| EIf b e1 e2 -> check_ok b sg && check_ok e1 sg && check_ok e2 sg
| ELam t e -> check_ok_ty t sg && check_ok e sg
| EApp e1 e2 -> check_ok e1 sg && check_ok e2 sg
#push-options "--fuel 2 --ifuel 2 --z3rlimit_factor 6 --query_stats"
let rec check (f:fstar_top_env)
(sg:src_env)
(e:src_exp { ok sg e })
: T.Tac (t:src_ty &
src_typing f sg e t)
= match e with
| EBVar _ ->
T.fail "Not locally nameless"
| EBool b ->
(| TBool, T_Bool _ b |)
| EVar n ->
begin
match lookup_ty sg n with
| None -> T.fail "Ill-typed"
| Some t ->
let d = T_Var sg n in
(| t, d |)
end
| ELam t body ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars body (EVar x) 0;
let (| tbody, dbody |) = check f ((x, Inl t)::sg) (open_exp body x) in
let dd : src_typing f sg e (TArrow t (close_ty tbody x)) =
T_Lam sg t body tbody x t_ok dbody in
(| TArrow t (close_ty tbody x), dd |)
| EApp e1 e2 ->
let (| t1, d1 |) = check f sg e1 in
let (| t2, d2 |) = check f sg e2 in
begin
match t1 with
| TArrow t_arg t_res ->
let st_ok = check_sub_typing f sg t2 t_arg in
(| open_ty_with t_res e2, T_App _ _ _ t_arg t_res _ d1 d2 st_ok |)
| _ ->
T.fail "Expected a function"
end
| EIf b e1 e2 ->
let (| tb, ok_b |) = check f sg b in
let hyp = fresh sg in
fresh_is_fresh sg;
if tb = TBool
then (
let (| t1, ok_1 |) = check f ((hyp, Inr(b, EBool true))::sg) e1 in
let (| t2, ok_2 |) = check f ((hyp, Inr(b, EBool false))::sg) e2 in
let (| t, w1, w2 |) = weaken f sg hyp b t1 t2 in
if not (check_ok_ty t sg)
then T.fail "Free variable escapes scope"
else (
let t_ok = check_ty f sg t in
(| t, T_If _ _ _ _ _ _ _ hyp ok_b ok_1 ok_2 w1 w2 t_ok |)
)
)
else T.fail "Branching on a non-boolean"
and check_ty (f:fstar_top_env)
(sg:src_env)
(t:src_ty { ok_ty sg t })
: T.Tac (src_ty_ok f sg t)
= match t with
| TBool -> OK_TBool _
| TArrow t t' ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_ty_freevars t' (EVar x) 0;
let t'_ok = check_ty f ((x, Inl t)::sg) (open_ty t' x) in
OK_TArrow _ _ _ x t_ok t'_ok
| TRefineBool e ->
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars e (EVar x) 0;
let (| te, de |) = check f ((x, Inl TBool)::sg) (open_exp e x) in
match te with
| TBool -> OK_TRefine sg e x de
| _ -> T.fail "Ill-typed refinement"
#pop-options | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
g: FStar.Stubs.Reflection.Types.env ->
sg: DependentBoolRefinement.src_env ->
x: DependentBoolRefinement.var
-> FStar.Pervasives.Lemma
(requires
forall (x: Prims.int).
FStar.Reflection.Typing.lookup_bvar g x == FStar.Pervasives.Native.None)
(ensures
((match DependentBoolRefinement.lookup sg x with
| FStar.Pervasives.Native.Some #_ b ->
FStar.Reflection.Typing.lookup_bvar (DependentBoolRefinement.extend_env_l g sg) x ==
FStar.Pervasives.Native.Some (DependentBoolRefinement.elab_binding b)
| FStar.Pervasives.Native.None #_ ->
FStar.Reflection.Typing.lookup_bvar (DependentBoolRefinement.extend_env_l g sg) x ==
FStar.Pervasives.Native.None)
<:
Type0))
(decreases sg)
[SMTPat (FStar.Reflection.Typing.lookup_bvar (DependentBoolRefinement.extend_env_l g sg) x)] | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Stubs.Reflection.Types.env",
"DependentBoolRefinement.src_env",
"DependentBoolRefinement.var",
"FStar.Pervasives.Native.tuple2",
"DependentBoolRefinement.binding",
"Prims.list",
"DependentBoolRefinement.extend_env_l_lookup_bvar",
"Prims.unit",
"Prims.l_Forall",
"Prims.int",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.Stubs.Reflection.Types.term",
"FStar.Reflection.Typing.lookup_bvar",
"FStar.Pervasives.Native.None",
"Prims.squash",
"DependentBoolRefinement.lookup",
"DependentBoolRefinement.extend_env_l",
"FStar.Pervasives.Native.Some",
"DependentBoolRefinement.elab_binding",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [
"recursion"
] | false | false | true | false | false | let rec extend_env_l_lookup_bvar (g: R.env) (sg: src_env) (x: var)
: Lemma (requires (forall x. RT.lookup_bvar g x == None))
(ensures
(match lookup sg x with
| Some b -> RT.lookup_bvar (extend_env_l g sg) x == Some (elab_binding b)
| None -> RT.lookup_bvar (extend_env_l g sg) x == None))
(decreases sg)
[SMTPat (RT.lookup_bvar (extend_env_l g sg) x)] =
| match sg with
| [] -> ()
| hd :: tl -> extend_env_l_lookup_bvar g tl x | false |
DependentBoolRefinement.fst | DependentBoolRefinement.extend_env_l_lookup_fvar | val extend_env_l_lookup_fvar (g: R.env) (sg: src_env) (fv: R.fv)
: Lemma (ensures RT.lookup_fvar (extend_env_l g sg) fv == RT.lookup_fvar g fv)
[SMTPat (RT.lookup_fvar (extend_env_l g sg) fv)] | val extend_env_l_lookup_fvar (g: R.env) (sg: src_env) (fv: R.fv)
: Lemma (ensures RT.lookup_fvar (extend_env_l g sg) fv == RT.lookup_fvar g fv)
[SMTPat (RT.lookup_fvar (extend_env_l g sg) fv)] | let rec extend_env_l_lookup_fvar (g:R.env) (sg:src_env) (fv:R.fv)
: Lemma
(ensures
RT.lookup_fvar (extend_env_l g sg) fv ==
RT.lookup_fvar g fv)
[SMTPat (RT.lookup_fvar (extend_env_l g sg) fv)]
= match sg with
| [] -> ()
| hd::tl -> extend_env_l_lookup_fvar g tl fv | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 48,
"end_line": 639,
"start_col": 0,
"start_line": 631
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1
let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1
let check_sub_typing f
(sg:src_env)
(t0 t1:src_ty)
: T.Tac (sub_typing f sg t0 t1)
= if t0 = t1 then S_Refl _ t0
else T.fail "Not subtypes"
let weaken (f:fstar_top_env) (sg:src_env) (hyp:var { None? (lookup sg hyp) } ) (b:src_exp) (t0 t1:src_ty)
: T.Tac (t:src_ty &
sub_typing f ((hyp,Inr(b, EBool true))::sg) t0 t &
sub_typing f ((hyp,Inr(b, EBool false))::sg) t1 t)
= if t0 = t1
then (| t0, S_Refl _ t0, S_Refl _ t1 |)
else T.fail "weaken is very dumb"
let ok (sg:src_env) (e:src_exp) = (forall x. x `Set.mem` freevars e ==> Some? (lookup sg x))
let ok_ty (sg:src_env) (e:src_ty) = (forall x. x `Set.mem` freevars_ty e ==> Some? (lookup sg x))
let rec check_ok_ty (t:src_ty) (sg:src_env)
: b:bool { b <==> (ok_ty sg t) }
= match t with
| TBool -> true
| TArrow t1 t2 ->
check_ok_ty t1 sg &&
check_ok_ty t2 sg
| TRefineBool e ->
check_ok e sg
and check_ok (e:src_exp) (sg:src_env)
: b:bool { b <==> ok sg e }
= match e with
| EBVar _ -> true
| EVar x -> Some? (lookup sg x)
| EBool _ -> true
| EIf b e1 e2 -> check_ok b sg && check_ok e1 sg && check_ok e2 sg
| ELam t e -> check_ok_ty t sg && check_ok e sg
| EApp e1 e2 -> check_ok e1 sg && check_ok e2 sg
#push-options "--fuel 2 --ifuel 2 --z3rlimit_factor 6 --query_stats"
let rec check (f:fstar_top_env)
(sg:src_env)
(e:src_exp { ok sg e })
: T.Tac (t:src_ty &
src_typing f sg e t)
= match e with
| EBVar _ ->
T.fail "Not locally nameless"
| EBool b ->
(| TBool, T_Bool _ b |)
| EVar n ->
begin
match lookup_ty sg n with
| None -> T.fail "Ill-typed"
| Some t ->
let d = T_Var sg n in
(| t, d |)
end
| ELam t body ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars body (EVar x) 0;
let (| tbody, dbody |) = check f ((x, Inl t)::sg) (open_exp body x) in
let dd : src_typing f sg e (TArrow t (close_ty tbody x)) =
T_Lam sg t body tbody x t_ok dbody in
(| TArrow t (close_ty tbody x), dd |)
| EApp e1 e2 ->
let (| t1, d1 |) = check f sg e1 in
let (| t2, d2 |) = check f sg e2 in
begin
match t1 with
| TArrow t_arg t_res ->
let st_ok = check_sub_typing f sg t2 t_arg in
(| open_ty_with t_res e2, T_App _ _ _ t_arg t_res _ d1 d2 st_ok |)
| _ ->
T.fail "Expected a function"
end
| EIf b e1 e2 ->
let (| tb, ok_b |) = check f sg b in
let hyp = fresh sg in
fresh_is_fresh sg;
if tb = TBool
then (
let (| t1, ok_1 |) = check f ((hyp, Inr(b, EBool true))::sg) e1 in
let (| t2, ok_2 |) = check f ((hyp, Inr(b, EBool false))::sg) e2 in
let (| t, w1, w2 |) = weaken f sg hyp b t1 t2 in
if not (check_ok_ty t sg)
then T.fail "Free variable escapes scope"
else (
let t_ok = check_ty f sg t in
(| t, T_If _ _ _ _ _ _ _ hyp ok_b ok_1 ok_2 w1 w2 t_ok |)
)
)
else T.fail "Branching on a non-boolean"
and check_ty (f:fstar_top_env)
(sg:src_env)
(t:src_ty { ok_ty sg t })
: T.Tac (src_ty_ok f sg t)
= match t with
| TBool -> OK_TBool _
| TArrow t t' ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_ty_freevars t' (EVar x) 0;
let t'_ok = check_ty f ((x, Inl t)::sg) (open_ty t' x) in
OK_TArrow _ _ _ x t_ok t'_ok
| TRefineBool e ->
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars e (EVar x) 0;
let (| te, de |) = check f ((x, Inl TBool)::sg) (open_exp e x) in
match te with
| TBool -> OK_TRefine sg e x de
| _ -> T.fail "Ill-typed refinement"
#pop-options
let rec extend_env_l_lookup_bvar (g:R.env) (sg:src_env) (x:var)
: Lemma
(requires (forall x. RT.lookup_bvar g x == None))
(ensures (
match lookup sg x with
| Some b -> RT.lookup_bvar (extend_env_l g sg) x == Some (elab_binding b)
| None -> RT.lookup_bvar (extend_env_l g sg) x == None))
(decreases sg)
[SMTPat (RT.lookup_bvar (extend_env_l g sg) x)]
= match sg with
| [] -> ()
| hd :: tl -> extend_env_l_lookup_bvar g tl x
#push-options "--query_stats --fuel 8 --ifuel 2 --z3rlimit_factor 2"
let rec elab_open_commute' (n:nat) (e:src_exp) (x:src_exp)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.DT n (elab_exp x) ] ==
elab_exp (open_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| EIf b e1 e2 ->
elab_open_commute' n b x;
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| ELam t e ->
elab_ty_open_commute' n t x;
elab_open_commute' (n + 1) e x
and elab_ty_open_commute' (n:nat) (e:src_ty) (x:src_exp)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.DT n (elab_exp x) ] ==
elab_ty (open_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_open_commute' n t x;
elab_ty_open_commute' (n + 1) t' x
| TRefineBool e ->
elab_open_commute' (n + 1) e x
#pop-options
let elab_open_commute (e:src_exp) (x:var)
: Lemma (RT.open_term (elab_exp e) x == elab_exp (open_exp e x))
[SMTPat (RT.open_term (elab_exp e) x)]
= elab_open_commute' 0 e (EVar x);
RT.open_term_spec (elab_exp e) x
let b2t_typing (g:fstar_env) (t:R.term) (dt:RT.tot_typing g t RT.bool_ty)
: RT.tot_typing g (r_b2t t) (RT.tm_type RT.u_zero)
= let b2t_typing : RT.tot_typing g _ b2t_ty = RT.T_FVar g b2t_fv in
let app_ty : _ = RT.T_App _ _ _ _ (RT.tm_type RT.u_zero) _ b2t_typing dt in
RT.open_with_spec (RT.tm_type RT.u_zero) t;
app_ty | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
g: FStar.Stubs.Reflection.Types.env ->
sg: DependentBoolRefinement.src_env ->
fv: FStar.Stubs.Reflection.Types.fv
-> FStar.Pervasives.Lemma
(ensures
FStar.Reflection.Typing.lookup_fvar (DependentBoolRefinement.extend_env_l g sg) fv ==
FStar.Reflection.Typing.lookup_fvar g fv)
[SMTPat (FStar.Reflection.Typing.lookup_fvar (DependentBoolRefinement.extend_env_l g sg) fv)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Stubs.Reflection.Types.env",
"DependentBoolRefinement.src_env",
"FStar.Stubs.Reflection.Types.fv",
"FStar.Pervasives.Native.tuple2",
"DependentBoolRefinement.var",
"DependentBoolRefinement.binding",
"Prims.list",
"DependentBoolRefinement.extend_env_l_lookup_fvar",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.Stubs.Reflection.Types.term",
"FStar.Reflection.Typing.lookup_fvar",
"DependentBoolRefinement.extend_env_l",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [
"recursion"
] | false | false | true | false | false | let rec extend_env_l_lookup_fvar (g: R.env) (sg: src_env) (fv: R.fv)
: Lemma (ensures RT.lookup_fvar (extend_env_l g sg) fv == RT.lookup_fvar g fv)
[SMTPat (RT.lookup_fvar (extend_env_l g sg) fv)] =
| match sg with
| [] -> ()
| hd :: tl -> extend_env_l_lookup_fvar g tl fv | false |
DependentBoolRefinement.fst | DependentBoolRefinement.elab_open_commute | val elab_open_commute (e: src_exp) (x: var)
: Lemma (RT.open_term (elab_exp e) x == elab_exp (open_exp e x))
[SMTPat (RT.open_term (elab_exp e) x)] | val elab_open_commute (e: src_exp) (x: var)
: Lemma (RT.open_term (elab_exp e) x == elab_exp (open_exp e x))
[SMTPat (RT.open_term (elab_exp e) x)] | let elab_open_commute (e:src_exp) (x:var)
: Lemma (RT.open_term (elab_exp e) x == elab_exp (open_exp e x))
[SMTPat (RT.open_term (elab_exp e) x)]
= elab_open_commute' 0 e (EVar x);
RT.open_term_spec (elab_exp e) x | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 622,
"start_col": 0,
"start_line": 618
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1
let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1
let check_sub_typing f
(sg:src_env)
(t0 t1:src_ty)
: T.Tac (sub_typing f sg t0 t1)
= if t0 = t1 then S_Refl _ t0
else T.fail "Not subtypes"
let weaken (f:fstar_top_env) (sg:src_env) (hyp:var { None? (lookup sg hyp) } ) (b:src_exp) (t0 t1:src_ty)
: T.Tac (t:src_ty &
sub_typing f ((hyp,Inr(b, EBool true))::sg) t0 t &
sub_typing f ((hyp,Inr(b, EBool false))::sg) t1 t)
= if t0 = t1
then (| t0, S_Refl _ t0, S_Refl _ t1 |)
else T.fail "weaken is very dumb"
let ok (sg:src_env) (e:src_exp) = (forall x. x `Set.mem` freevars e ==> Some? (lookup sg x))
let ok_ty (sg:src_env) (e:src_ty) = (forall x. x `Set.mem` freevars_ty e ==> Some? (lookup sg x))
let rec check_ok_ty (t:src_ty) (sg:src_env)
: b:bool { b <==> (ok_ty sg t) }
= match t with
| TBool -> true
| TArrow t1 t2 ->
check_ok_ty t1 sg &&
check_ok_ty t2 sg
| TRefineBool e ->
check_ok e sg
and check_ok (e:src_exp) (sg:src_env)
: b:bool { b <==> ok sg e }
= match e with
| EBVar _ -> true
| EVar x -> Some? (lookup sg x)
| EBool _ -> true
| EIf b e1 e2 -> check_ok b sg && check_ok e1 sg && check_ok e2 sg
| ELam t e -> check_ok_ty t sg && check_ok e sg
| EApp e1 e2 -> check_ok e1 sg && check_ok e2 sg
#push-options "--fuel 2 --ifuel 2 --z3rlimit_factor 6 --query_stats"
let rec check (f:fstar_top_env)
(sg:src_env)
(e:src_exp { ok sg e })
: T.Tac (t:src_ty &
src_typing f sg e t)
= match e with
| EBVar _ ->
T.fail "Not locally nameless"
| EBool b ->
(| TBool, T_Bool _ b |)
| EVar n ->
begin
match lookup_ty sg n with
| None -> T.fail "Ill-typed"
| Some t ->
let d = T_Var sg n in
(| t, d |)
end
| ELam t body ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars body (EVar x) 0;
let (| tbody, dbody |) = check f ((x, Inl t)::sg) (open_exp body x) in
let dd : src_typing f sg e (TArrow t (close_ty tbody x)) =
T_Lam sg t body tbody x t_ok dbody in
(| TArrow t (close_ty tbody x), dd |)
| EApp e1 e2 ->
let (| t1, d1 |) = check f sg e1 in
let (| t2, d2 |) = check f sg e2 in
begin
match t1 with
| TArrow t_arg t_res ->
let st_ok = check_sub_typing f sg t2 t_arg in
(| open_ty_with t_res e2, T_App _ _ _ t_arg t_res _ d1 d2 st_ok |)
| _ ->
T.fail "Expected a function"
end
| EIf b e1 e2 ->
let (| tb, ok_b |) = check f sg b in
let hyp = fresh sg in
fresh_is_fresh sg;
if tb = TBool
then (
let (| t1, ok_1 |) = check f ((hyp, Inr(b, EBool true))::sg) e1 in
let (| t2, ok_2 |) = check f ((hyp, Inr(b, EBool false))::sg) e2 in
let (| t, w1, w2 |) = weaken f sg hyp b t1 t2 in
if not (check_ok_ty t sg)
then T.fail "Free variable escapes scope"
else (
let t_ok = check_ty f sg t in
(| t, T_If _ _ _ _ _ _ _ hyp ok_b ok_1 ok_2 w1 w2 t_ok |)
)
)
else T.fail "Branching on a non-boolean"
and check_ty (f:fstar_top_env)
(sg:src_env)
(t:src_ty { ok_ty sg t })
: T.Tac (src_ty_ok f sg t)
= match t with
| TBool -> OK_TBool _
| TArrow t t' ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_ty_freevars t' (EVar x) 0;
let t'_ok = check_ty f ((x, Inl t)::sg) (open_ty t' x) in
OK_TArrow _ _ _ x t_ok t'_ok
| TRefineBool e ->
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars e (EVar x) 0;
let (| te, de |) = check f ((x, Inl TBool)::sg) (open_exp e x) in
match te with
| TBool -> OK_TRefine sg e x de
| _ -> T.fail "Ill-typed refinement"
#pop-options
let rec extend_env_l_lookup_bvar (g:R.env) (sg:src_env) (x:var)
: Lemma
(requires (forall x. RT.lookup_bvar g x == None))
(ensures (
match lookup sg x with
| Some b -> RT.lookup_bvar (extend_env_l g sg) x == Some (elab_binding b)
| None -> RT.lookup_bvar (extend_env_l g sg) x == None))
(decreases sg)
[SMTPat (RT.lookup_bvar (extend_env_l g sg) x)]
= match sg with
| [] -> ()
| hd :: tl -> extend_env_l_lookup_bvar g tl x
#push-options "--query_stats --fuel 8 --ifuel 2 --z3rlimit_factor 2"
let rec elab_open_commute' (n:nat) (e:src_exp) (x:src_exp)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.DT n (elab_exp x) ] ==
elab_exp (open_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| EIf b e1 e2 ->
elab_open_commute' n b x;
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| ELam t e ->
elab_ty_open_commute' n t x;
elab_open_commute' (n + 1) e x
and elab_ty_open_commute' (n:nat) (e:src_ty) (x:src_exp)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.DT n (elab_exp x) ] ==
elab_ty (open_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_open_commute' n t x;
elab_ty_open_commute' (n + 1) t' x
| TRefineBool e ->
elab_open_commute' (n + 1) e x
#pop-options | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | e: DependentBoolRefinement.src_exp -> x: DependentBoolRefinement.var
-> FStar.Pervasives.Lemma
(ensures
FStar.Reflection.Typing.open_term (DependentBoolRefinement.elab_exp e) x ==
DependentBoolRefinement.elab_exp (DependentBoolRefinement.open_exp e x))
[SMTPat (FStar.Reflection.Typing.open_term (DependentBoolRefinement.elab_exp e) x)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.var",
"FStar.Reflection.Typing.open_term_spec",
"DependentBoolRefinement.elab_exp",
"Prims.unit",
"DependentBoolRefinement.elab_open_commute'",
"DependentBoolRefinement.EVar",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Stubs.Reflection.Types.term",
"FStar.Reflection.Typing.open_term",
"DependentBoolRefinement.open_exp",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | true | false | true | false | false | let elab_open_commute (e: src_exp) (x: var)
: Lemma (RT.open_term (elab_exp e) x == elab_exp (open_exp e x))
[SMTPat (RT.open_term (elab_exp e) x)] =
| elab_open_commute' 0 e (EVar x);
RT.open_term_spec (elab_exp e) x | false |
Vale.Arch.Heap.fst | Vale.Arch.Heap.heap_create_impl | val heap_create_impl (ih:interop_heap) (mt:memTaint_t) : Ghost heap_impl
(requires True)
(ensures fun hi -> heap_get hi == heap_create_machine ih /\ heap_taint hi == mt) | val heap_create_impl (ih:interop_heap) (mt:memTaint_t) : Ghost heap_impl
(requires True)
(ensures fun hi -> heap_get hi == heap_create_machine ih /\ heap_taint hi == mt) | let heap_create_impl ih mt =
let vh = one_heaplet ih None in
let layout = {vl_inner = empty_vale_heap_layout_inner vh; vl_taint = mt;} in
{
vf_layout = layout;
vf_heap = vh;
vf_heaplets = empty_vale_heaplets vh;
} | {
"file_name": "vale/code/arch/Vale.Arch.Heap.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 46,
"start_col": 0,
"start_line": 39
} | module Vale.Arch.Heap
open FStar.Mul
open Vale.Interop
open Vale.Arch.HeapImpl
module Map16 = Vale.Lib.Map16
friend Vale.Arch.HeapImpl
let heap_impl = vale_full_heap
let heap_get hi = hi.vf_heap.mh
let heap_taint hi = hi.vf_layout.vl_taint
// Update heaplet k with mh', but only for the addresses that k owns (addresses not owned by k remain unmodified)
let heaplet_upd_f (vfh:vale_full_heap) (mh':machine_heap) (k:heaplet_id) : vale_heap =
let hk = Map16.sel vfh.vf_heaplets k in
let mhk = hk.mh in
let dom_upd = Set.intersect (vfh.vf_layout.vl_inner.vl_heaplet_sets k) (Map.domain mhk) in
let mhk' = Map.concat mhk (Map.restrict dom_upd mh') in
mi_heap_upd hk mhk'
let heap_upd hi mh' mt' =
let h' = mi_heap_upd hi.vf_heap mh' in
let hs' = Map16.init vale_heap (heaplet_upd_f hi mh') in
{
vf_layout = {hi.vf_layout with vl_taint = mt'};
vf_heap = h';
vf_heaplets = hs';
}
let heap_create_machine ih =
down_mem ih
let one_heaplet (ih:interop_heap) (id:option heaplet_id) : GTot vale_heap =
let m = down_mem ih in
let g = Ghost.hide ih in
ValeHeap m g id | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Map16.fsti.checked",
"Vale.Interop.fsti.checked",
"Vale.Arch.HeapImpl.fst.checked",
"Vale.Arch.HeapImpl.fst.checked",
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Arch.Heap.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Heap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | ih: Vale.Interop.Heap_s.interop_heap -> mt: Vale.Arch.HeapTypes_s.memTaint_t
-> Prims.Ghost Vale.Arch.Heap.heap_impl | Prims.Ghost | [] | [] | [
"Vale.Interop.Heap_s.interop_heap",
"Vale.Arch.HeapTypes_s.memTaint_t",
"Vale.Arch.HeapImpl.Mkvale_full_heap",
"Vale.Arch.HeapImpl.empty_vale_heaplets",
"Vale.Arch.HeapImpl.vale_heap_layout",
"Vale.Arch.HeapImpl.Mkvale_heap_layout",
"Vale.Arch.HeapImpl.empty_vale_heap_layout_inner",
"Vale.Arch.HeapImpl.vale_heap",
"Vale.Arch.Heap.one_heaplet",
"FStar.Pervasives.Native.None",
"Vale.Arch.HeapImpl.heaplet_id",
"Vale.Arch.Heap.heap_impl"
] | [] | false | false | false | false | false | let heap_create_impl ih mt =
| let vh = one_heaplet ih None in
let layout = { vl_inner = empty_vale_heap_layout_inner vh; vl_taint = mt } in
{ vf_layout = layout; vf_heap = vh; vf_heaplets = empty_vale_heaplets vh } | false |
DependentBoolRefinement.fst | DependentBoolRefinement.elab_ty_open_commute | val elab_ty_open_commute (e: src_ty) (v: var)
: Lemma (RT.open_term (elab_ty e) v == elab_ty (open_ty e v))
[SMTPat (RT.open_term (elab_ty e) v)] | val elab_ty_open_commute (e: src_ty) (v: var)
: Lemma (RT.open_term (elab_ty e) v == elab_ty (open_ty e v))
[SMTPat (RT.open_term (elab_ty e) v)] | let elab_ty_open_commute (e:src_ty) (v:var)
: Lemma (RT.open_term (elab_ty e) v == elab_ty (open_ty e v))
[SMTPat (RT.open_term (elab_ty e) v)]
= elab_ty_open_commute' 0 e (EVar v);
RT.open_term_spec (elab_ty e) v | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 35,
"end_line": 702,
"start_col": 0,
"start_line": 698
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1
let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1
let check_sub_typing f
(sg:src_env)
(t0 t1:src_ty)
: T.Tac (sub_typing f sg t0 t1)
= if t0 = t1 then S_Refl _ t0
else T.fail "Not subtypes"
let weaken (f:fstar_top_env) (sg:src_env) (hyp:var { None? (lookup sg hyp) } ) (b:src_exp) (t0 t1:src_ty)
: T.Tac (t:src_ty &
sub_typing f ((hyp,Inr(b, EBool true))::sg) t0 t &
sub_typing f ((hyp,Inr(b, EBool false))::sg) t1 t)
= if t0 = t1
then (| t0, S_Refl _ t0, S_Refl _ t1 |)
else T.fail "weaken is very dumb"
let ok (sg:src_env) (e:src_exp) = (forall x. x `Set.mem` freevars e ==> Some? (lookup sg x))
let ok_ty (sg:src_env) (e:src_ty) = (forall x. x `Set.mem` freevars_ty e ==> Some? (lookup sg x))
let rec check_ok_ty (t:src_ty) (sg:src_env)
: b:bool { b <==> (ok_ty sg t) }
= match t with
| TBool -> true
| TArrow t1 t2 ->
check_ok_ty t1 sg &&
check_ok_ty t2 sg
| TRefineBool e ->
check_ok e sg
and check_ok (e:src_exp) (sg:src_env)
: b:bool { b <==> ok sg e }
= match e with
| EBVar _ -> true
| EVar x -> Some? (lookup sg x)
| EBool _ -> true
| EIf b e1 e2 -> check_ok b sg && check_ok e1 sg && check_ok e2 sg
| ELam t e -> check_ok_ty t sg && check_ok e sg
| EApp e1 e2 -> check_ok e1 sg && check_ok e2 sg
#push-options "--fuel 2 --ifuel 2 --z3rlimit_factor 6 --query_stats"
let rec check (f:fstar_top_env)
(sg:src_env)
(e:src_exp { ok sg e })
: T.Tac (t:src_ty &
src_typing f sg e t)
= match e with
| EBVar _ ->
T.fail "Not locally nameless"
| EBool b ->
(| TBool, T_Bool _ b |)
| EVar n ->
begin
match lookup_ty sg n with
| None -> T.fail "Ill-typed"
| Some t ->
let d = T_Var sg n in
(| t, d |)
end
| ELam t body ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars body (EVar x) 0;
let (| tbody, dbody |) = check f ((x, Inl t)::sg) (open_exp body x) in
let dd : src_typing f sg e (TArrow t (close_ty tbody x)) =
T_Lam sg t body tbody x t_ok dbody in
(| TArrow t (close_ty tbody x), dd |)
| EApp e1 e2 ->
let (| t1, d1 |) = check f sg e1 in
let (| t2, d2 |) = check f sg e2 in
begin
match t1 with
| TArrow t_arg t_res ->
let st_ok = check_sub_typing f sg t2 t_arg in
(| open_ty_with t_res e2, T_App _ _ _ t_arg t_res _ d1 d2 st_ok |)
| _ ->
T.fail "Expected a function"
end
| EIf b e1 e2 ->
let (| tb, ok_b |) = check f sg b in
let hyp = fresh sg in
fresh_is_fresh sg;
if tb = TBool
then (
let (| t1, ok_1 |) = check f ((hyp, Inr(b, EBool true))::sg) e1 in
let (| t2, ok_2 |) = check f ((hyp, Inr(b, EBool false))::sg) e2 in
let (| t, w1, w2 |) = weaken f sg hyp b t1 t2 in
if not (check_ok_ty t sg)
then T.fail "Free variable escapes scope"
else (
let t_ok = check_ty f sg t in
(| t, T_If _ _ _ _ _ _ _ hyp ok_b ok_1 ok_2 w1 w2 t_ok |)
)
)
else T.fail "Branching on a non-boolean"
and check_ty (f:fstar_top_env)
(sg:src_env)
(t:src_ty { ok_ty sg t })
: T.Tac (src_ty_ok f sg t)
= match t with
| TBool -> OK_TBool _
| TArrow t t' ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_ty_freevars t' (EVar x) 0;
let t'_ok = check_ty f ((x, Inl t)::sg) (open_ty t' x) in
OK_TArrow _ _ _ x t_ok t'_ok
| TRefineBool e ->
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars e (EVar x) 0;
let (| te, de |) = check f ((x, Inl TBool)::sg) (open_exp e x) in
match te with
| TBool -> OK_TRefine sg e x de
| _ -> T.fail "Ill-typed refinement"
#pop-options
let rec extend_env_l_lookup_bvar (g:R.env) (sg:src_env) (x:var)
: Lemma
(requires (forall x. RT.lookup_bvar g x == None))
(ensures (
match lookup sg x with
| Some b -> RT.lookup_bvar (extend_env_l g sg) x == Some (elab_binding b)
| None -> RT.lookup_bvar (extend_env_l g sg) x == None))
(decreases sg)
[SMTPat (RT.lookup_bvar (extend_env_l g sg) x)]
= match sg with
| [] -> ()
| hd :: tl -> extend_env_l_lookup_bvar g tl x
#push-options "--query_stats --fuel 8 --ifuel 2 --z3rlimit_factor 2"
let rec elab_open_commute' (n:nat) (e:src_exp) (x:src_exp)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.DT n (elab_exp x) ] ==
elab_exp (open_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| EIf b e1 e2 ->
elab_open_commute' n b x;
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| ELam t e ->
elab_ty_open_commute' n t x;
elab_open_commute' (n + 1) e x
and elab_ty_open_commute' (n:nat) (e:src_ty) (x:src_exp)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.DT n (elab_exp x) ] ==
elab_ty (open_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_open_commute' n t x;
elab_ty_open_commute' (n + 1) t' x
| TRefineBool e ->
elab_open_commute' (n + 1) e x
#pop-options
let elab_open_commute (e:src_exp) (x:var)
: Lemma (RT.open_term (elab_exp e) x == elab_exp (open_exp e x))
[SMTPat (RT.open_term (elab_exp e) x)]
= elab_open_commute' 0 e (EVar x);
RT.open_term_spec (elab_exp e) x
let b2t_typing (g:fstar_env) (t:R.term) (dt:RT.tot_typing g t RT.bool_ty)
: RT.tot_typing g (r_b2t t) (RT.tm_type RT.u_zero)
= let b2t_typing : RT.tot_typing g _ b2t_ty = RT.T_FVar g b2t_fv in
let app_ty : _ = RT.T_App _ _ _ _ (RT.tm_type RT.u_zero) _ b2t_typing dt in
RT.open_with_spec (RT.tm_type RT.u_zero) t;
app_ty
let rec extend_env_l_lookup_fvar (g:R.env) (sg:src_env) (fv:R.fv)
: Lemma
(ensures
RT.lookup_fvar (extend_env_l g sg) fv ==
RT.lookup_fvar g fv)
[SMTPat (RT.lookup_fvar (extend_env_l g sg) fv)]
= match sg with
| [] -> ()
| hd::tl -> extend_env_l_lookup_fvar g tl fv
#push-options "--query_stats --fuel 2 --ifuel 2 --z3rlimit_factor 2"
let subtyping_soundness #f (#sg:src_env) (#t0 #t1:src_ty) (ds:sub_typing f sg t0 t1)
: GTot (RT.sub_typing (extend_env_l f sg) (elab_ty t0) (elab_ty t1))
= match ds with
| S_Refl _ _ -> RT.Rel_equiv _ _ _ _ (RT.Rel_refl _ _ _)
| S_ELab _ _ _ d -> d
#push-options "--query_stats --fuel 8 --ifuel 2 --z3rlimit_factor 4"
let rec elab_close_commute' (n:nat) (e:src_exp) (x:var)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.ND x n ] ==
elab_exp (close_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_close_commute' n e1 x;
elab_close_commute' n e2 x
| EIf b e1 e2 ->
elab_close_commute' n b x;
elab_close_commute' n e1 x;
elab_close_commute' n e2 x
| ELam t e ->
elab_ty_close_commute' n t x;
elab_close_commute' (n + 1) e x
and elab_ty_close_commute' (n:nat) (e:src_ty) (x:var)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.ND x n ] ==
elab_ty (close_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_close_commute' n t x;
elab_ty_close_commute' (n + 1) t' x
| TRefineBool e ->
elab_close_commute' (n + 1) e x
#pop-options
let elab_ty_close_commute (e:src_ty) (x:var)
: Lemma (RT.close_term (elab_ty e) x == elab_ty (close_ty e x))
[SMTPat (RT.close_term (elab_ty e) x)]
= RT.close_term_spec (elab_ty e) x;
elab_ty_close_commute' 0 e x
let elab_ty_open_with_commute (e:src_ty) (v:src_exp)
: Lemma (RT.open_with (elab_ty e) (elab_exp v) == elab_ty (open_ty_with e v))
[SMTPat (RT.open_with (elab_ty e) (elab_exp v))]
= elab_ty_open_commute' 0 e v;
RT.open_with_spec (elab_ty e) (elab_exp v) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 2,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 2,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | e: DependentBoolRefinement.src_ty -> v: DependentBoolRefinement.var
-> FStar.Pervasives.Lemma
(ensures
FStar.Reflection.Typing.open_term (DependentBoolRefinement.elab_ty e) v ==
DependentBoolRefinement.elab_ty (DependentBoolRefinement.open_ty e v))
[SMTPat (FStar.Reflection.Typing.open_term (DependentBoolRefinement.elab_ty e) v)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.var",
"FStar.Reflection.Typing.open_term_spec",
"DependentBoolRefinement.elab_ty",
"Prims.unit",
"DependentBoolRefinement.elab_ty_open_commute'",
"DependentBoolRefinement.EVar",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Stubs.Reflection.Types.term",
"FStar.Reflection.Typing.open_term",
"DependentBoolRefinement.open_ty",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | true | false | true | false | false | let elab_ty_open_commute (e: src_ty) (v: var)
: Lemma (RT.open_term (elab_ty e) v == elab_ty (open_ty e v))
[SMTPat (RT.open_term (elab_ty e) v)] =
| elab_ty_open_commute' 0 e (EVar v);
RT.open_term_spec (elab_ty e) v | false |
Vale.Arch.Heap.fst | Vale.Arch.Heap.heap_upd | val heap_upd (hi:heap_impl) (mh':machine_heap) (mt':memTaint_t) : Pure heap_impl
(requires is_machine_heap_update (heap_get hi) mh')
(ensures fun hi -> heap_get hi == mh' /\ heap_taint hi == mt') | val heap_upd (hi:heap_impl) (mh':machine_heap) (mt':memTaint_t) : Pure heap_impl
(requires is_machine_heap_update (heap_get hi) mh')
(ensures fun hi -> heap_get hi == mh' /\ heap_taint hi == mt') | let heap_upd hi mh' mt' =
let h' = mi_heap_upd hi.vf_heap mh' in
let hs' = Map16.init vale_heap (heaplet_upd_f hi mh') in
{
vf_layout = {hi.vf_layout with vl_taint = mt'};
vf_heap = h';
vf_heaplets = hs';
} | {
"file_name": "vale/code/arch/Vale.Arch.Heap.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 29,
"start_col": 0,
"start_line": 22
} | module Vale.Arch.Heap
open FStar.Mul
open Vale.Interop
open Vale.Arch.HeapImpl
module Map16 = Vale.Lib.Map16
friend Vale.Arch.HeapImpl
let heap_impl = vale_full_heap
let heap_get hi = hi.vf_heap.mh
let heap_taint hi = hi.vf_layout.vl_taint
// Update heaplet k with mh', but only for the addresses that k owns (addresses not owned by k remain unmodified)
let heaplet_upd_f (vfh:vale_full_heap) (mh':machine_heap) (k:heaplet_id) : vale_heap =
let hk = Map16.sel vfh.vf_heaplets k in
let mhk = hk.mh in
let dom_upd = Set.intersect (vfh.vf_layout.vl_inner.vl_heaplet_sets k) (Map.domain mhk) in
let mhk' = Map.concat mhk (Map.restrict dom_upd mh') in
mi_heap_upd hk mhk' | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Map16.fsti.checked",
"Vale.Interop.fsti.checked",
"Vale.Arch.HeapImpl.fst.checked",
"Vale.Arch.HeapImpl.fst.checked",
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Map.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Arch.Heap.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Heap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.MachineHeap_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
hi: Vale.Arch.Heap.heap_impl ->
mh': Vale.Arch.MachineHeap_s.machine_heap ->
mt': Vale.Arch.HeapTypes_s.memTaint_t
-> Prims.Pure Vale.Arch.Heap.heap_impl | Prims.Pure | [] | [] | [
"Vale.Arch.Heap.heap_impl",
"Vale.Arch.MachineHeap_s.machine_heap",
"Vale.Arch.HeapTypes_s.memTaint_t",
"Vale.Arch.HeapImpl.Mkvale_full_heap",
"Vale.Arch.HeapImpl.Mkvale_heap_layout",
"Vale.Arch.HeapImpl.__proj__Mkvale_heap_layout__item__vl_inner",
"Vale.Arch.HeapImpl.vale_heap_layout",
"Vale.Arch.HeapImpl.__proj__Mkvale_full_heap__item__vf_layout",
"Vale.Lib.Map16.map16",
"Vale.Arch.HeapImpl.vale_heap",
"Vale.Lib.Map16.init",
"Vale.Arch.Heap.heaplet_upd_f",
"Vale.Arch.HeapImpl.mi_heap_upd",
"Vale.Arch.HeapImpl.__proj__Mkvale_full_heap__item__vf_heap"
] | [] | false | false | false | false | false | let heap_upd hi mh' mt' =
| let h' = mi_heap_upd hi.vf_heap mh' in
let hs' = Map16.init vale_heap (heaplet_upd_f hi mh') in
{ vf_layout = { hi.vf_layout with vl_taint = mt' }; vf_heap = h'; vf_heaplets = hs' } | false |
DependentBoolRefinement.fst | DependentBoolRefinement.elab_ty_close_commute | val elab_ty_close_commute (e: src_ty) (x: var)
: Lemma (RT.close_term (elab_ty e) x == elab_ty (close_ty e x))
[SMTPat (RT.close_term (elab_ty e) x)] | val elab_ty_close_commute (e: src_ty) (x: var)
: Lemma (RT.close_term (elab_ty e) x == elab_ty (close_ty e x))
[SMTPat (RT.close_term (elab_ty e) x)] | let elab_ty_close_commute (e:src_ty) (x:var)
: Lemma (RT.close_term (elab_ty e) x == elab_ty (close_ty e x))
[SMTPat (RT.close_term (elab_ty e) x)]
= RT.close_term_spec (elab_ty e) x;
elab_ty_close_commute' 0 e x | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 32,
"end_line": 690,
"start_col": 0,
"start_line": 686
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1
let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1
let check_sub_typing f
(sg:src_env)
(t0 t1:src_ty)
: T.Tac (sub_typing f sg t0 t1)
= if t0 = t1 then S_Refl _ t0
else T.fail "Not subtypes"
let weaken (f:fstar_top_env) (sg:src_env) (hyp:var { None? (lookup sg hyp) } ) (b:src_exp) (t0 t1:src_ty)
: T.Tac (t:src_ty &
sub_typing f ((hyp,Inr(b, EBool true))::sg) t0 t &
sub_typing f ((hyp,Inr(b, EBool false))::sg) t1 t)
= if t0 = t1
then (| t0, S_Refl _ t0, S_Refl _ t1 |)
else T.fail "weaken is very dumb"
let ok (sg:src_env) (e:src_exp) = (forall x. x `Set.mem` freevars e ==> Some? (lookup sg x))
let ok_ty (sg:src_env) (e:src_ty) = (forall x. x `Set.mem` freevars_ty e ==> Some? (lookup sg x))
let rec check_ok_ty (t:src_ty) (sg:src_env)
: b:bool { b <==> (ok_ty sg t) }
= match t with
| TBool -> true
| TArrow t1 t2 ->
check_ok_ty t1 sg &&
check_ok_ty t2 sg
| TRefineBool e ->
check_ok e sg
and check_ok (e:src_exp) (sg:src_env)
: b:bool { b <==> ok sg e }
= match e with
| EBVar _ -> true
| EVar x -> Some? (lookup sg x)
| EBool _ -> true
| EIf b e1 e2 -> check_ok b sg && check_ok e1 sg && check_ok e2 sg
| ELam t e -> check_ok_ty t sg && check_ok e sg
| EApp e1 e2 -> check_ok e1 sg && check_ok e2 sg
#push-options "--fuel 2 --ifuel 2 --z3rlimit_factor 6 --query_stats"
let rec check (f:fstar_top_env)
(sg:src_env)
(e:src_exp { ok sg e })
: T.Tac (t:src_ty &
src_typing f sg e t)
= match e with
| EBVar _ ->
T.fail "Not locally nameless"
| EBool b ->
(| TBool, T_Bool _ b |)
| EVar n ->
begin
match lookup_ty sg n with
| None -> T.fail "Ill-typed"
| Some t ->
let d = T_Var sg n in
(| t, d |)
end
| ELam t body ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars body (EVar x) 0;
let (| tbody, dbody |) = check f ((x, Inl t)::sg) (open_exp body x) in
let dd : src_typing f sg e (TArrow t (close_ty tbody x)) =
T_Lam sg t body tbody x t_ok dbody in
(| TArrow t (close_ty tbody x), dd |)
| EApp e1 e2 ->
let (| t1, d1 |) = check f sg e1 in
let (| t2, d2 |) = check f sg e2 in
begin
match t1 with
| TArrow t_arg t_res ->
let st_ok = check_sub_typing f sg t2 t_arg in
(| open_ty_with t_res e2, T_App _ _ _ t_arg t_res _ d1 d2 st_ok |)
| _ ->
T.fail "Expected a function"
end
| EIf b e1 e2 ->
let (| tb, ok_b |) = check f sg b in
let hyp = fresh sg in
fresh_is_fresh sg;
if tb = TBool
then (
let (| t1, ok_1 |) = check f ((hyp, Inr(b, EBool true))::sg) e1 in
let (| t2, ok_2 |) = check f ((hyp, Inr(b, EBool false))::sg) e2 in
let (| t, w1, w2 |) = weaken f sg hyp b t1 t2 in
if not (check_ok_ty t sg)
then T.fail "Free variable escapes scope"
else (
let t_ok = check_ty f sg t in
(| t, T_If _ _ _ _ _ _ _ hyp ok_b ok_1 ok_2 w1 w2 t_ok |)
)
)
else T.fail "Branching on a non-boolean"
and check_ty (f:fstar_top_env)
(sg:src_env)
(t:src_ty { ok_ty sg t })
: T.Tac (src_ty_ok f sg t)
= match t with
| TBool -> OK_TBool _
| TArrow t t' ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_ty_freevars t' (EVar x) 0;
let t'_ok = check_ty f ((x, Inl t)::sg) (open_ty t' x) in
OK_TArrow _ _ _ x t_ok t'_ok
| TRefineBool e ->
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars e (EVar x) 0;
let (| te, de |) = check f ((x, Inl TBool)::sg) (open_exp e x) in
match te with
| TBool -> OK_TRefine sg e x de
| _ -> T.fail "Ill-typed refinement"
#pop-options
let rec extend_env_l_lookup_bvar (g:R.env) (sg:src_env) (x:var)
: Lemma
(requires (forall x. RT.lookup_bvar g x == None))
(ensures (
match lookup sg x with
| Some b -> RT.lookup_bvar (extend_env_l g sg) x == Some (elab_binding b)
| None -> RT.lookup_bvar (extend_env_l g sg) x == None))
(decreases sg)
[SMTPat (RT.lookup_bvar (extend_env_l g sg) x)]
= match sg with
| [] -> ()
| hd :: tl -> extend_env_l_lookup_bvar g tl x
#push-options "--query_stats --fuel 8 --ifuel 2 --z3rlimit_factor 2"
let rec elab_open_commute' (n:nat) (e:src_exp) (x:src_exp)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.DT n (elab_exp x) ] ==
elab_exp (open_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| EIf b e1 e2 ->
elab_open_commute' n b x;
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| ELam t e ->
elab_ty_open_commute' n t x;
elab_open_commute' (n + 1) e x
and elab_ty_open_commute' (n:nat) (e:src_ty) (x:src_exp)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.DT n (elab_exp x) ] ==
elab_ty (open_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_open_commute' n t x;
elab_ty_open_commute' (n + 1) t' x
| TRefineBool e ->
elab_open_commute' (n + 1) e x
#pop-options
let elab_open_commute (e:src_exp) (x:var)
: Lemma (RT.open_term (elab_exp e) x == elab_exp (open_exp e x))
[SMTPat (RT.open_term (elab_exp e) x)]
= elab_open_commute' 0 e (EVar x);
RT.open_term_spec (elab_exp e) x
let b2t_typing (g:fstar_env) (t:R.term) (dt:RT.tot_typing g t RT.bool_ty)
: RT.tot_typing g (r_b2t t) (RT.tm_type RT.u_zero)
= let b2t_typing : RT.tot_typing g _ b2t_ty = RT.T_FVar g b2t_fv in
let app_ty : _ = RT.T_App _ _ _ _ (RT.tm_type RT.u_zero) _ b2t_typing dt in
RT.open_with_spec (RT.tm_type RT.u_zero) t;
app_ty
let rec extend_env_l_lookup_fvar (g:R.env) (sg:src_env) (fv:R.fv)
: Lemma
(ensures
RT.lookup_fvar (extend_env_l g sg) fv ==
RT.lookup_fvar g fv)
[SMTPat (RT.lookup_fvar (extend_env_l g sg) fv)]
= match sg with
| [] -> ()
| hd::tl -> extend_env_l_lookup_fvar g tl fv
#push-options "--query_stats --fuel 2 --ifuel 2 --z3rlimit_factor 2"
let subtyping_soundness #f (#sg:src_env) (#t0 #t1:src_ty) (ds:sub_typing f sg t0 t1)
: GTot (RT.sub_typing (extend_env_l f sg) (elab_ty t0) (elab_ty t1))
= match ds with
| S_Refl _ _ -> RT.Rel_equiv _ _ _ _ (RT.Rel_refl _ _ _)
| S_ELab _ _ _ d -> d
#push-options "--query_stats --fuel 8 --ifuel 2 --z3rlimit_factor 4"
let rec elab_close_commute' (n:nat) (e:src_exp) (x:var)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.ND x n ] ==
elab_exp (close_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_close_commute' n e1 x;
elab_close_commute' n e2 x
| EIf b e1 e2 ->
elab_close_commute' n b x;
elab_close_commute' n e1 x;
elab_close_commute' n e2 x
| ELam t e ->
elab_ty_close_commute' n t x;
elab_close_commute' (n + 1) e x
and elab_ty_close_commute' (n:nat) (e:src_ty) (x:var)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.ND x n ] ==
elab_ty (close_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_close_commute' n t x;
elab_ty_close_commute' (n + 1) t' x
| TRefineBool e ->
elab_close_commute' (n + 1) e x
#pop-options | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 2,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 2,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | e: DependentBoolRefinement.src_ty -> x: DependentBoolRefinement.var
-> FStar.Pervasives.Lemma
(ensures
FStar.Reflection.Typing.close_term (DependentBoolRefinement.elab_ty e) x ==
DependentBoolRefinement.elab_ty (DependentBoolRefinement.close_ty e x))
[SMTPat (FStar.Reflection.Typing.close_term (DependentBoolRefinement.elab_ty e) x)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.var",
"DependentBoolRefinement.elab_ty_close_commute'",
"Prims.unit",
"FStar.Reflection.Typing.close_term_spec",
"DependentBoolRefinement.elab_ty",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Stubs.Reflection.Types.term",
"FStar.Reflection.Typing.close_term",
"DependentBoolRefinement.close_ty",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | true | false | true | false | false | let elab_ty_close_commute (e: src_ty) (x: var)
: Lemma (RT.close_term (elab_ty e) x == elab_ty (close_ty e x))
[SMTPat (RT.close_term (elab_ty e) x)] =
| RT.close_term_spec (elab_ty e) x;
elab_ty_close_commute' 0 e x | false |
DependentBoolRefinement.fst | DependentBoolRefinement.elab_open_b2t | val elab_open_b2t (e: src_exp) (x: var)
: Lemma (RT.open_term (r_b2t (elab_exp e)) x == r_b2t (elab_exp (open_exp e x))) | val elab_open_b2t (e: src_exp) (x: var)
: Lemma (RT.open_term (r_b2t (elab_exp e)) x == r_b2t (elab_exp (open_exp e x))) | let elab_open_b2t (e:src_exp) (x:var)
: Lemma (RT.open_term (r_b2t (elab_exp e)) x ==
r_b2t (elab_exp (open_exp e x)))
= RT.open_term_spec (r_b2t (elab_exp e)) x;
RT.open_term_spec (elab_exp e) x | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 708,
"start_col": 0,
"start_line": 704
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1
let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1
let check_sub_typing f
(sg:src_env)
(t0 t1:src_ty)
: T.Tac (sub_typing f sg t0 t1)
= if t0 = t1 then S_Refl _ t0
else T.fail "Not subtypes"
let weaken (f:fstar_top_env) (sg:src_env) (hyp:var { None? (lookup sg hyp) } ) (b:src_exp) (t0 t1:src_ty)
: T.Tac (t:src_ty &
sub_typing f ((hyp,Inr(b, EBool true))::sg) t0 t &
sub_typing f ((hyp,Inr(b, EBool false))::sg) t1 t)
= if t0 = t1
then (| t0, S_Refl _ t0, S_Refl _ t1 |)
else T.fail "weaken is very dumb"
let ok (sg:src_env) (e:src_exp) = (forall x. x `Set.mem` freevars e ==> Some? (lookup sg x))
let ok_ty (sg:src_env) (e:src_ty) = (forall x. x `Set.mem` freevars_ty e ==> Some? (lookup sg x))
let rec check_ok_ty (t:src_ty) (sg:src_env)
: b:bool { b <==> (ok_ty sg t) }
= match t with
| TBool -> true
| TArrow t1 t2 ->
check_ok_ty t1 sg &&
check_ok_ty t2 sg
| TRefineBool e ->
check_ok e sg
and check_ok (e:src_exp) (sg:src_env)
: b:bool { b <==> ok sg e }
= match e with
| EBVar _ -> true
| EVar x -> Some? (lookup sg x)
| EBool _ -> true
| EIf b e1 e2 -> check_ok b sg && check_ok e1 sg && check_ok e2 sg
| ELam t e -> check_ok_ty t sg && check_ok e sg
| EApp e1 e2 -> check_ok e1 sg && check_ok e2 sg
#push-options "--fuel 2 --ifuel 2 --z3rlimit_factor 6 --query_stats"
let rec check (f:fstar_top_env)
(sg:src_env)
(e:src_exp { ok sg e })
: T.Tac (t:src_ty &
src_typing f sg e t)
= match e with
| EBVar _ ->
T.fail "Not locally nameless"
| EBool b ->
(| TBool, T_Bool _ b |)
| EVar n ->
begin
match lookup_ty sg n with
| None -> T.fail "Ill-typed"
| Some t ->
let d = T_Var sg n in
(| t, d |)
end
| ELam t body ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars body (EVar x) 0;
let (| tbody, dbody |) = check f ((x, Inl t)::sg) (open_exp body x) in
let dd : src_typing f sg e (TArrow t (close_ty tbody x)) =
T_Lam sg t body tbody x t_ok dbody in
(| TArrow t (close_ty tbody x), dd |)
| EApp e1 e2 ->
let (| t1, d1 |) = check f sg e1 in
let (| t2, d2 |) = check f sg e2 in
begin
match t1 with
| TArrow t_arg t_res ->
let st_ok = check_sub_typing f sg t2 t_arg in
(| open_ty_with t_res e2, T_App _ _ _ t_arg t_res _ d1 d2 st_ok |)
| _ ->
T.fail "Expected a function"
end
| EIf b e1 e2 ->
let (| tb, ok_b |) = check f sg b in
let hyp = fresh sg in
fresh_is_fresh sg;
if tb = TBool
then (
let (| t1, ok_1 |) = check f ((hyp, Inr(b, EBool true))::sg) e1 in
let (| t2, ok_2 |) = check f ((hyp, Inr(b, EBool false))::sg) e2 in
let (| t, w1, w2 |) = weaken f sg hyp b t1 t2 in
if not (check_ok_ty t sg)
then T.fail "Free variable escapes scope"
else (
let t_ok = check_ty f sg t in
(| t, T_If _ _ _ _ _ _ _ hyp ok_b ok_1 ok_2 w1 w2 t_ok |)
)
)
else T.fail "Branching on a non-boolean"
and check_ty (f:fstar_top_env)
(sg:src_env)
(t:src_ty { ok_ty sg t })
: T.Tac (src_ty_ok f sg t)
= match t with
| TBool -> OK_TBool _
| TArrow t t' ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_ty_freevars t' (EVar x) 0;
let t'_ok = check_ty f ((x, Inl t)::sg) (open_ty t' x) in
OK_TArrow _ _ _ x t_ok t'_ok
| TRefineBool e ->
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars e (EVar x) 0;
let (| te, de |) = check f ((x, Inl TBool)::sg) (open_exp e x) in
match te with
| TBool -> OK_TRefine sg e x de
| _ -> T.fail "Ill-typed refinement"
#pop-options
let rec extend_env_l_lookup_bvar (g:R.env) (sg:src_env) (x:var)
: Lemma
(requires (forall x. RT.lookup_bvar g x == None))
(ensures (
match lookup sg x with
| Some b -> RT.lookup_bvar (extend_env_l g sg) x == Some (elab_binding b)
| None -> RT.lookup_bvar (extend_env_l g sg) x == None))
(decreases sg)
[SMTPat (RT.lookup_bvar (extend_env_l g sg) x)]
= match sg with
| [] -> ()
| hd :: tl -> extend_env_l_lookup_bvar g tl x
#push-options "--query_stats --fuel 8 --ifuel 2 --z3rlimit_factor 2"
let rec elab_open_commute' (n:nat) (e:src_exp) (x:src_exp)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.DT n (elab_exp x) ] ==
elab_exp (open_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| EIf b e1 e2 ->
elab_open_commute' n b x;
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| ELam t e ->
elab_ty_open_commute' n t x;
elab_open_commute' (n + 1) e x
and elab_ty_open_commute' (n:nat) (e:src_ty) (x:src_exp)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.DT n (elab_exp x) ] ==
elab_ty (open_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_open_commute' n t x;
elab_ty_open_commute' (n + 1) t' x
| TRefineBool e ->
elab_open_commute' (n + 1) e x
#pop-options
let elab_open_commute (e:src_exp) (x:var)
: Lemma (RT.open_term (elab_exp e) x == elab_exp (open_exp e x))
[SMTPat (RT.open_term (elab_exp e) x)]
= elab_open_commute' 0 e (EVar x);
RT.open_term_spec (elab_exp e) x
let b2t_typing (g:fstar_env) (t:R.term) (dt:RT.tot_typing g t RT.bool_ty)
: RT.tot_typing g (r_b2t t) (RT.tm_type RT.u_zero)
= let b2t_typing : RT.tot_typing g _ b2t_ty = RT.T_FVar g b2t_fv in
let app_ty : _ = RT.T_App _ _ _ _ (RT.tm_type RT.u_zero) _ b2t_typing dt in
RT.open_with_spec (RT.tm_type RT.u_zero) t;
app_ty
let rec extend_env_l_lookup_fvar (g:R.env) (sg:src_env) (fv:R.fv)
: Lemma
(ensures
RT.lookup_fvar (extend_env_l g sg) fv ==
RT.lookup_fvar g fv)
[SMTPat (RT.lookup_fvar (extend_env_l g sg) fv)]
= match sg with
| [] -> ()
| hd::tl -> extend_env_l_lookup_fvar g tl fv
#push-options "--query_stats --fuel 2 --ifuel 2 --z3rlimit_factor 2"
let subtyping_soundness #f (#sg:src_env) (#t0 #t1:src_ty) (ds:sub_typing f sg t0 t1)
: GTot (RT.sub_typing (extend_env_l f sg) (elab_ty t0) (elab_ty t1))
= match ds with
| S_Refl _ _ -> RT.Rel_equiv _ _ _ _ (RT.Rel_refl _ _ _)
| S_ELab _ _ _ d -> d
#push-options "--query_stats --fuel 8 --ifuel 2 --z3rlimit_factor 4"
let rec elab_close_commute' (n:nat) (e:src_exp) (x:var)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.ND x n ] ==
elab_exp (close_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_close_commute' n e1 x;
elab_close_commute' n e2 x
| EIf b e1 e2 ->
elab_close_commute' n b x;
elab_close_commute' n e1 x;
elab_close_commute' n e2 x
| ELam t e ->
elab_ty_close_commute' n t x;
elab_close_commute' (n + 1) e x
and elab_ty_close_commute' (n:nat) (e:src_ty) (x:var)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.ND x n ] ==
elab_ty (close_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_close_commute' n t x;
elab_ty_close_commute' (n + 1) t' x
| TRefineBool e ->
elab_close_commute' (n + 1) e x
#pop-options
let elab_ty_close_commute (e:src_ty) (x:var)
: Lemma (RT.close_term (elab_ty e) x == elab_ty (close_ty e x))
[SMTPat (RT.close_term (elab_ty e) x)]
= RT.close_term_spec (elab_ty e) x;
elab_ty_close_commute' 0 e x
let elab_ty_open_with_commute (e:src_ty) (v:src_exp)
: Lemma (RT.open_with (elab_ty e) (elab_exp v) == elab_ty (open_ty_with e v))
[SMTPat (RT.open_with (elab_ty e) (elab_exp v))]
= elab_ty_open_commute' 0 e v;
RT.open_with_spec (elab_ty e) (elab_exp v)
let elab_ty_open_commute (e:src_ty) (v:var)
: Lemma (RT.open_term (elab_ty e) v == elab_ty (open_ty e v))
[SMTPat (RT.open_term (elab_ty e) v)]
= elab_ty_open_commute' 0 e (EVar v);
RT.open_term_spec (elab_ty e) v | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 2,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 2,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | e: DependentBoolRefinement.src_exp -> x: DependentBoolRefinement.var
-> FStar.Pervasives.Lemma
(ensures
FStar.Reflection.Typing.open_term (DependentBoolRefinement.r_b2t (DependentBoolRefinement.elab_exp
e))
x ==
DependentBoolRefinement.r_b2t (DependentBoolRefinement.elab_exp (DependentBoolRefinement.open_exp
e
x))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.var",
"FStar.Reflection.Typing.open_term_spec",
"DependentBoolRefinement.elab_exp",
"Prims.unit",
"DependentBoolRefinement.r_b2t",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Stubs.Reflection.Types.term",
"FStar.Reflection.Typing.open_term",
"DependentBoolRefinement.open_exp",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let elab_open_b2t (e: src_exp) (x: var)
: Lemma (RT.open_term (r_b2t (elab_exp e)) x == r_b2t (elab_exp (open_exp e x))) =
| RT.open_term_spec (r_b2t (elab_exp e)) x;
RT.open_term_spec (elab_exp e) x | false |
DependentBoolRefinement.fst | DependentBoolRefinement.soundness_lemma | val soundness_lemma (f: fstar_top_env) (sg: src_env{src_env_ok sg}) (se: src_exp) (st: src_ty)
: Lemma (requires src_typing f sg se st)
(ensures RT.tot_typing (extend_env_l f sg) (elab_exp se) (elab_ty st)) | val soundness_lemma (f: fstar_top_env) (sg: src_env{src_env_ok sg}) (se: src_exp) (st: src_ty)
: Lemma (requires src_typing f sg se st)
(ensures RT.tot_typing (extend_env_l f sg) (elab_exp se) (elab_ty st)) | let soundness_lemma (f:fstar_top_env)
(sg:src_env { src_env_ok sg })
(se:src_exp)
(st:src_ty)
: Lemma
(requires src_typing f sg se st)
(ensures RT.tot_typing (extend_env_l f sg)
(elab_exp se)
(elab_ty st))
= FStar.Squash.bind_squash
#(src_typing f sg se st)
()
(fun dd -> FStar.Squash.return_squash (soundness dd)) | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 59,
"end_line": 860,
"start_col": 0,
"start_line": 848
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1
let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1
let check_sub_typing f
(sg:src_env)
(t0 t1:src_ty)
: T.Tac (sub_typing f sg t0 t1)
= if t0 = t1 then S_Refl _ t0
else T.fail "Not subtypes"
let weaken (f:fstar_top_env) (sg:src_env) (hyp:var { None? (lookup sg hyp) } ) (b:src_exp) (t0 t1:src_ty)
: T.Tac (t:src_ty &
sub_typing f ((hyp,Inr(b, EBool true))::sg) t0 t &
sub_typing f ((hyp,Inr(b, EBool false))::sg) t1 t)
= if t0 = t1
then (| t0, S_Refl _ t0, S_Refl _ t1 |)
else T.fail "weaken is very dumb"
let ok (sg:src_env) (e:src_exp) = (forall x. x `Set.mem` freevars e ==> Some? (lookup sg x))
let ok_ty (sg:src_env) (e:src_ty) = (forall x. x `Set.mem` freevars_ty e ==> Some? (lookup sg x))
let rec check_ok_ty (t:src_ty) (sg:src_env)
: b:bool { b <==> (ok_ty sg t) }
= match t with
| TBool -> true
| TArrow t1 t2 ->
check_ok_ty t1 sg &&
check_ok_ty t2 sg
| TRefineBool e ->
check_ok e sg
and check_ok (e:src_exp) (sg:src_env)
: b:bool { b <==> ok sg e }
= match e with
| EBVar _ -> true
| EVar x -> Some? (lookup sg x)
| EBool _ -> true
| EIf b e1 e2 -> check_ok b sg && check_ok e1 sg && check_ok e2 sg
| ELam t e -> check_ok_ty t sg && check_ok e sg
| EApp e1 e2 -> check_ok e1 sg && check_ok e2 sg
#push-options "--fuel 2 --ifuel 2 --z3rlimit_factor 6 --query_stats"
let rec check (f:fstar_top_env)
(sg:src_env)
(e:src_exp { ok sg e })
: T.Tac (t:src_ty &
src_typing f sg e t)
= match e with
| EBVar _ ->
T.fail "Not locally nameless"
| EBool b ->
(| TBool, T_Bool _ b |)
| EVar n ->
begin
match lookup_ty sg n with
| None -> T.fail "Ill-typed"
| Some t ->
let d = T_Var sg n in
(| t, d |)
end
| ELam t body ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars body (EVar x) 0;
let (| tbody, dbody |) = check f ((x, Inl t)::sg) (open_exp body x) in
let dd : src_typing f sg e (TArrow t (close_ty tbody x)) =
T_Lam sg t body tbody x t_ok dbody in
(| TArrow t (close_ty tbody x), dd |)
| EApp e1 e2 ->
let (| t1, d1 |) = check f sg e1 in
let (| t2, d2 |) = check f sg e2 in
begin
match t1 with
| TArrow t_arg t_res ->
let st_ok = check_sub_typing f sg t2 t_arg in
(| open_ty_with t_res e2, T_App _ _ _ t_arg t_res _ d1 d2 st_ok |)
| _ ->
T.fail "Expected a function"
end
| EIf b e1 e2 ->
let (| tb, ok_b |) = check f sg b in
let hyp = fresh sg in
fresh_is_fresh sg;
if tb = TBool
then (
let (| t1, ok_1 |) = check f ((hyp, Inr(b, EBool true))::sg) e1 in
let (| t2, ok_2 |) = check f ((hyp, Inr(b, EBool false))::sg) e2 in
let (| t, w1, w2 |) = weaken f sg hyp b t1 t2 in
if not (check_ok_ty t sg)
then T.fail "Free variable escapes scope"
else (
let t_ok = check_ty f sg t in
(| t, T_If _ _ _ _ _ _ _ hyp ok_b ok_1 ok_2 w1 w2 t_ok |)
)
)
else T.fail "Branching on a non-boolean"
and check_ty (f:fstar_top_env)
(sg:src_env)
(t:src_ty { ok_ty sg t })
: T.Tac (src_ty_ok f sg t)
= match t with
| TBool -> OK_TBool _
| TArrow t t' ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_ty_freevars t' (EVar x) 0;
let t'_ok = check_ty f ((x, Inl t)::sg) (open_ty t' x) in
OK_TArrow _ _ _ x t_ok t'_ok
| TRefineBool e ->
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars e (EVar x) 0;
let (| te, de |) = check f ((x, Inl TBool)::sg) (open_exp e x) in
match te with
| TBool -> OK_TRefine sg e x de
| _ -> T.fail "Ill-typed refinement"
#pop-options
let rec extend_env_l_lookup_bvar (g:R.env) (sg:src_env) (x:var)
: Lemma
(requires (forall x. RT.lookup_bvar g x == None))
(ensures (
match lookup sg x with
| Some b -> RT.lookup_bvar (extend_env_l g sg) x == Some (elab_binding b)
| None -> RT.lookup_bvar (extend_env_l g sg) x == None))
(decreases sg)
[SMTPat (RT.lookup_bvar (extend_env_l g sg) x)]
= match sg with
| [] -> ()
| hd :: tl -> extend_env_l_lookup_bvar g tl x
#push-options "--query_stats --fuel 8 --ifuel 2 --z3rlimit_factor 2"
let rec elab_open_commute' (n:nat) (e:src_exp) (x:src_exp)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.DT n (elab_exp x) ] ==
elab_exp (open_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| EIf b e1 e2 ->
elab_open_commute' n b x;
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| ELam t e ->
elab_ty_open_commute' n t x;
elab_open_commute' (n + 1) e x
and elab_ty_open_commute' (n:nat) (e:src_ty) (x:src_exp)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.DT n (elab_exp x) ] ==
elab_ty (open_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_open_commute' n t x;
elab_ty_open_commute' (n + 1) t' x
| TRefineBool e ->
elab_open_commute' (n + 1) e x
#pop-options
let elab_open_commute (e:src_exp) (x:var)
: Lemma (RT.open_term (elab_exp e) x == elab_exp (open_exp e x))
[SMTPat (RT.open_term (elab_exp e) x)]
= elab_open_commute' 0 e (EVar x);
RT.open_term_spec (elab_exp e) x
let b2t_typing (g:fstar_env) (t:R.term) (dt:RT.tot_typing g t RT.bool_ty)
: RT.tot_typing g (r_b2t t) (RT.tm_type RT.u_zero)
= let b2t_typing : RT.tot_typing g _ b2t_ty = RT.T_FVar g b2t_fv in
let app_ty : _ = RT.T_App _ _ _ _ (RT.tm_type RT.u_zero) _ b2t_typing dt in
RT.open_with_spec (RT.tm_type RT.u_zero) t;
app_ty
let rec extend_env_l_lookup_fvar (g:R.env) (sg:src_env) (fv:R.fv)
: Lemma
(ensures
RT.lookup_fvar (extend_env_l g sg) fv ==
RT.lookup_fvar g fv)
[SMTPat (RT.lookup_fvar (extend_env_l g sg) fv)]
= match sg with
| [] -> ()
| hd::tl -> extend_env_l_lookup_fvar g tl fv
#push-options "--query_stats --fuel 2 --ifuel 2 --z3rlimit_factor 2"
let subtyping_soundness #f (#sg:src_env) (#t0 #t1:src_ty) (ds:sub_typing f sg t0 t1)
: GTot (RT.sub_typing (extend_env_l f sg) (elab_ty t0) (elab_ty t1))
= match ds with
| S_Refl _ _ -> RT.Rel_equiv _ _ _ _ (RT.Rel_refl _ _ _)
| S_ELab _ _ _ d -> d
#push-options "--query_stats --fuel 8 --ifuel 2 --z3rlimit_factor 4"
let rec elab_close_commute' (n:nat) (e:src_exp) (x:var)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.ND x n ] ==
elab_exp (close_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_close_commute' n e1 x;
elab_close_commute' n e2 x
| EIf b e1 e2 ->
elab_close_commute' n b x;
elab_close_commute' n e1 x;
elab_close_commute' n e2 x
| ELam t e ->
elab_ty_close_commute' n t x;
elab_close_commute' (n + 1) e x
and elab_ty_close_commute' (n:nat) (e:src_ty) (x:var)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.ND x n ] ==
elab_ty (close_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_close_commute' n t x;
elab_ty_close_commute' (n + 1) t' x
| TRefineBool e ->
elab_close_commute' (n + 1) e x
#pop-options
let elab_ty_close_commute (e:src_ty) (x:var)
: Lemma (RT.close_term (elab_ty e) x == elab_ty (close_ty e x))
[SMTPat (RT.close_term (elab_ty e) x)]
= RT.close_term_spec (elab_ty e) x;
elab_ty_close_commute' 0 e x
let elab_ty_open_with_commute (e:src_ty) (v:src_exp)
: Lemma (RT.open_with (elab_ty e) (elab_exp v) == elab_ty (open_ty_with e v))
[SMTPat (RT.open_with (elab_ty e) (elab_exp v))]
= elab_ty_open_commute' 0 e v;
RT.open_with_spec (elab_ty e) (elab_exp v)
let elab_ty_open_commute (e:src_ty) (v:var)
: Lemma (RT.open_term (elab_ty e) v == elab_ty (open_ty e v))
[SMTPat (RT.open_term (elab_ty e) v)]
= elab_ty_open_commute' 0 e (EVar v);
RT.open_term_spec (elab_ty e) v
let elab_open_b2t (e:src_exp) (x:var)
: Lemma (RT.open_term (r_b2t (elab_exp e)) x ==
r_b2t (elab_exp (open_exp e x)))
= RT.open_term_spec (r_b2t (elab_exp e)) x;
RT.open_term_spec (elab_exp e) x
let rec soundness (#f:fstar_top_env)
(#sg:src_env { src_env_ok sg } )
(#se:src_exp)
(#st:src_ty)
(dd:src_typing f sg se st)
: GTot (RT.tot_typing (extend_env_l f sg)
(elab_exp se)
(elab_ty st))
(decreases (height dd))
= match dd with
| T_Bool _ true ->
RT.T_Const _ _ _ RT.CT_True
| T_Bool _ false ->
RT.T_Const _ _ _ RT.CT_False
| T_Var _ x ->
RT.T_Var _ (R.pack_namedv (RT.make_namedv x))
| T_Lam _ t e t' x dt de ->
let de : RT.tot_typing (extend_env_l f ((x,Inl t)::sg))
(elab_exp (open_exp e x))
(elab_ty t')
= soundness de
in
let de : RT.tot_typing (RT.extend_env (extend_env_l f sg) x (elab_ty t))
(elab_exp (open_exp e x))
(elab_ty t')
= de
in
fresh_is_fresh sg;
freevars_elab_exp e;
let dt : RT.tot_typing (extend_env_l f sg) (elab_ty t) (RT.tm_type RT.u_zero) =
src_ty_ok_soundness sg t dt
in
let dd
: RT.tot_typing (extend_env_l f sg)
(R.pack_ln (R.Tv_Abs (RT.mk_simple_binder RT.pp_name_default (elab_ty t)) (elab_exp e)))
(elab_ty (TArrow t (close_ty t' x)))
= RT.close_term_spec (elab_ty t') x;
assert (elab_ty (close_ty t' x) ==
RT.subst_term (elab_ty t') [ RT.ND x 0 ]);
RT.T_Abs (extend_env_l f sg)
x
(elab_ty t)
(elab_exp e)
(T.E_Total, elab_ty t')
_
_
_
_
dt
de
in
dd
| T_If _ b e1 e2 t1 t2 t hyp db d1 d2 s1 s2 tok ->
let db = soundness db in
let d1 = soundness d1 in
let d2 = soundness d2 in
let s1 = subtyping_soundness s1 in
let s2 = subtyping_soundness s2 in
let t_ok = src_ty_ok_soundness sg t tok in
let d1 = RT.T_Sub _ _ _ _ d1 (RT.Relc_typ _ _ _ _ _ s1) in
let d2 = RT.T_Sub _ _ _ _ d2 (RT.Relc_typ _ _ _ _ _ s2) in
freevars_elab_exp e1;
freevars_elab_exp e2;
RT.T_If (extend_env_l f sg) (elab_exp b) (elab_exp e1) (elab_exp e2) _ _ hyp _ _ db d1 d2 t_ok
| T_App _ e1 e2 t t' t0 d1 d2 st ->
let dt1
: RT.tot_typing (extend_env_l f sg)
(elab_exp e1)
(elab_ty (TArrow t t'))
= soundness d1
in
let dt2
: RT.tot_typing (extend_env_l f sg)
(elab_exp e2)
(elab_ty t0)
= soundness d2
in
let st
: RT.sub_typing (extend_env_l f sg) (elab_ty t0) (elab_ty t)
= subtyping_soundness st
in
let dt2
: RT.tot_typing (extend_env_l f sg)
(elab_exp e2)
(elab_ty t)
= RT.T_Sub _ _ _ _ dt2 (RT.Relc_typ _ _ _ _ _ st)
in
RT.T_App _ _ _ _ (elab_ty t') _ dt1 dt2
and src_ty_ok_soundness (#f:fstar_top_env)
(sg:src_env { src_env_ok sg })
(t:src_ty)
(dt:src_ty_ok f sg t)
: GTot (RT.tot_typing (extend_env_l f sg) (elab_ty t) (RT.tm_type RT.u_zero))
(decreases (t_height dt))
= match dt with
| OK_TBool _ ->
RT.T_FVar _ RT.bool_fv
| OK_TArrow _ t1 t2 x ok_t1 ok_t2 ->
let t1_ok = src_ty_ok_soundness sg _ ok_t1 in
let t2_ok = src_ty_ok_soundness ((x, Inl t1)::sg) _ ok_t2 in
freevars_elab_ty t2;
let arr_max = RT.T_Arrow _ x (elab_ty t1) (elab_ty t2) _ _ RT.pp_name_default R.Q_Explicit T.E_Total _ _ t1_ok t2_ok in
RT.simplify_umax arr_max
| OK_TRefine _ e x de ->
let de
: RT.tot_typing (RT.extend_env (extend_env_l f sg) x RT.bool_ty)
(elab_exp (open_exp e x))
(elab_ty TBool)
= soundness de
in
let de
: RT.tot_typing (RT.extend_env (extend_env_l f sg) x RT.bool_ty)
(r_b2t (elab_exp (open_exp e x)))
(RT.tm_type RT.u_zero)
= b2t_typing _ _ de
in
let bool_typing
: RT.tot_typing (extend_env_l f sg) RT.bool_ty (RT.tm_type RT.u_zero)
= RT.T_FVar _ RT.bool_fv
in
elab_open_b2t e x;
freevars_elab_exp e;
RT.T_Refine (extend_env_l f sg)
x
RT.bool_ty
(r_b2t (elab_exp e))
_ _ _ _
bool_typing
de | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 2,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 2,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
f: DependentBoolRefinement.fstar_top_env ->
sg: DependentBoolRefinement.src_env{DependentBoolRefinement.src_env_ok sg} ->
se: DependentBoolRefinement.src_exp ->
st: DependentBoolRefinement.src_ty
-> FStar.Pervasives.Lemma (requires DependentBoolRefinement.src_typing f sg se st)
(ensures
FStar.Reflection.Typing.tot_typing (DependentBoolRefinement.extend_env_l f sg)
(DependentBoolRefinement.elab_exp se)
(DependentBoolRefinement.elab_ty st)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"DependentBoolRefinement.fstar_top_env",
"DependentBoolRefinement.src_env",
"Prims.b2t",
"DependentBoolRefinement.src_env_ok",
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.src_ty",
"FStar.Squash.bind_squash",
"DependentBoolRefinement.src_typing",
"FStar.Reflection.Typing.tot_typing",
"DependentBoolRefinement.extend_env_l",
"DependentBoolRefinement.elab_exp",
"DependentBoolRefinement.elab_ty",
"FStar.Squash.return_squash",
"DependentBoolRefinement.soundness",
"Prims.squash",
"Prims.unit",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let soundness_lemma (f: fstar_top_env) (sg: src_env{src_env_ok sg}) (se: src_exp) (st: src_ty)
: Lemma (requires src_typing f sg se st)
(ensures RT.tot_typing (extend_env_l f sg) (elab_exp se) (elab_ty st)) =
| FStar.Squash.bind_squash #(src_typing f sg se st)
()
(fun dd -> FStar.Squash.return_squash (soundness dd)) | false |
DependentBoolRefinement.fst | DependentBoolRefinement.closed_ty | val closed_ty (t: src_ty) : b: bool{b <==> ((freevars_ty t) `Set.equal` Set.empty)} | val closed_ty (t: src_ty) : b: bool{b <==> ((freevars_ty t) `Set.equal` Set.empty)} | let rec closed (s:src_exp)
: b:bool { b <==> (freevars s `Set.equal` Set.empty) }
= match s with
| EBool _
| EBVar _ -> true
| EVar m -> assert (m `Set.mem` freevars s); false
| EIf b e1 e2 -> closed b && closed e1 && closed e2
| ELam t e -> closed_ty t && closed e
| EApp e1 e2 -> closed e1 && closed e2
and closed_ty (t:src_ty)
: b:bool { b <==> (freevars_ty t `Set.equal` Set.empty) }
= match t with
| TBool -> true
| TRefineBool e -> closed e
| TArrow t1 t2 -> closed_ty t1 && closed_ty t2 | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 50,
"end_line": 877,
"start_col": 0,
"start_line": 862
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1
let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1
let check_sub_typing f
(sg:src_env)
(t0 t1:src_ty)
: T.Tac (sub_typing f sg t0 t1)
= if t0 = t1 then S_Refl _ t0
else T.fail "Not subtypes"
let weaken (f:fstar_top_env) (sg:src_env) (hyp:var { None? (lookup sg hyp) } ) (b:src_exp) (t0 t1:src_ty)
: T.Tac (t:src_ty &
sub_typing f ((hyp,Inr(b, EBool true))::sg) t0 t &
sub_typing f ((hyp,Inr(b, EBool false))::sg) t1 t)
= if t0 = t1
then (| t0, S_Refl _ t0, S_Refl _ t1 |)
else T.fail "weaken is very dumb"
let ok (sg:src_env) (e:src_exp) = (forall x. x `Set.mem` freevars e ==> Some? (lookup sg x))
let ok_ty (sg:src_env) (e:src_ty) = (forall x. x `Set.mem` freevars_ty e ==> Some? (lookup sg x))
let rec check_ok_ty (t:src_ty) (sg:src_env)
: b:bool { b <==> (ok_ty sg t) }
= match t with
| TBool -> true
| TArrow t1 t2 ->
check_ok_ty t1 sg &&
check_ok_ty t2 sg
| TRefineBool e ->
check_ok e sg
and check_ok (e:src_exp) (sg:src_env)
: b:bool { b <==> ok sg e }
= match e with
| EBVar _ -> true
| EVar x -> Some? (lookup sg x)
| EBool _ -> true
| EIf b e1 e2 -> check_ok b sg && check_ok e1 sg && check_ok e2 sg
| ELam t e -> check_ok_ty t sg && check_ok e sg
| EApp e1 e2 -> check_ok e1 sg && check_ok e2 sg
#push-options "--fuel 2 --ifuel 2 --z3rlimit_factor 6 --query_stats"
let rec check (f:fstar_top_env)
(sg:src_env)
(e:src_exp { ok sg e })
: T.Tac (t:src_ty &
src_typing f sg e t)
= match e with
| EBVar _ ->
T.fail "Not locally nameless"
| EBool b ->
(| TBool, T_Bool _ b |)
| EVar n ->
begin
match lookup_ty sg n with
| None -> T.fail "Ill-typed"
| Some t ->
let d = T_Var sg n in
(| t, d |)
end
| ELam t body ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars body (EVar x) 0;
let (| tbody, dbody |) = check f ((x, Inl t)::sg) (open_exp body x) in
let dd : src_typing f sg e (TArrow t (close_ty tbody x)) =
T_Lam sg t body tbody x t_ok dbody in
(| TArrow t (close_ty tbody x), dd |)
| EApp e1 e2 ->
let (| t1, d1 |) = check f sg e1 in
let (| t2, d2 |) = check f sg e2 in
begin
match t1 with
| TArrow t_arg t_res ->
let st_ok = check_sub_typing f sg t2 t_arg in
(| open_ty_with t_res e2, T_App _ _ _ t_arg t_res _ d1 d2 st_ok |)
| _ ->
T.fail "Expected a function"
end
| EIf b e1 e2 ->
let (| tb, ok_b |) = check f sg b in
let hyp = fresh sg in
fresh_is_fresh sg;
if tb = TBool
then (
let (| t1, ok_1 |) = check f ((hyp, Inr(b, EBool true))::sg) e1 in
let (| t2, ok_2 |) = check f ((hyp, Inr(b, EBool false))::sg) e2 in
let (| t, w1, w2 |) = weaken f sg hyp b t1 t2 in
if not (check_ok_ty t sg)
then T.fail "Free variable escapes scope"
else (
let t_ok = check_ty f sg t in
(| t, T_If _ _ _ _ _ _ _ hyp ok_b ok_1 ok_2 w1 w2 t_ok |)
)
)
else T.fail "Branching on a non-boolean"
and check_ty (f:fstar_top_env)
(sg:src_env)
(t:src_ty { ok_ty sg t })
: T.Tac (src_ty_ok f sg t)
= match t with
| TBool -> OK_TBool _
| TArrow t t' ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_ty_freevars t' (EVar x) 0;
let t'_ok = check_ty f ((x, Inl t)::sg) (open_ty t' x) in
OK_TArrow _ _ _ x t_ok t'_ok
| TRefineBool e ->
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars e (EVar x) 0;
let (| te, de |) = check f ((x, Inl TBool)::sg) (open_exp e x) in
match te with
| TBool -> OK_TRefine sg e x de
| _ -> T.fail "Ill-typed refinement"
#pop-options
let rec extend_env_l_lookup_bvar (g:R.env) (sg:src_env) (x:var)
: Lemma
(requires (forall x. RT.lookup_bvar g x == None))
(ensures (
match lookup sg x with
| Some b -> RT.lookup_bvar (extend_env_l g sg) x == Some (elab_binding b)
| None -> RT.lookup_bvar (extend_env_l g sg) x == None))
(decreases sg)
[SMTPat (RT.lookup_bvar (extend_env_l g sg) x)]
= match sg with
| [] -> ()
| hd :: tl -> extend_env_l_lookup_bvar g tl x
#push-options "--query_stats --fuel 8 --ifuel 2 --z3rlimit_factor 2"
let rec elab_open_commute' (n:nat) (e:src_exp) (x:src_exp)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.DT n (elab_exp x) ] ==
elab_exp (open_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| EIf b e1 e2 ->
elab_open_commute' n b x;
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| ELam t e ->
elab_ty_open_commute' n t x;
elab_open_commute' (n + 1) e x
and elab_ty_open_commute' (n:nat) (e:src_ty) (x:src_exp)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.DT n (elab_exp x) ] ==
elab_ty (open_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_open_commute' n t x;
elab_ty_open_commute' (n + 1) t' x
| TRefineBool e ->
elab_open_commute' (n + 1) e x
#pop-options
let elab_open_commute (e:src_exp) (x:var)
: Lemma (RT.open_term (elab_exp e) x == elab_exp (open_exp e x))
[SMTPat (RT.open_term (elab_exp e) x)]
= elab_open_commute' 0 e (EVar x);
RT.open_term_spec (elab_exp e) x
let b2t_typing (g:fstar_env) (t:R.term) (dt:RT.tot_typing g t RT.bool_ty)
: RT.tot_typing g (r_b2t t) (RT.tm_type RT.u_zero)
= let b2t_typing : RT.tot_typing g _ b2t_ty = RT.T_FVar g b2t_fv in
let app_ty : _ = RT.T_App _ _ _ _ (RT.tm_type RT.u_zero) _ b2t_typing dt in
RT.open_with_spec (RT.tm_type RT.u_zero) t;
app_ty
let rec extend_env_l_lookup_fvar (g:R.env) (sg:src_env) (fv:R.fv)
: Lemma
(ensures
RT.lookup_fvar (extend_env_l g sg) fv ==
RT.lookup_fvar g fv)
[SMTPat (RT.lookup_fvar (extend_env_l g sg) fv)]
= match sg with
| [] -> ()
| hd::tl -> extend_env_l_lookup_fvar g tl fv
#push-options "--query_stats --fuel 2 --ifuel 2 --z3rlimit_factor 2"
let subtyping_soundness #f (#sg:src_env) (#t0 #t1:src_ty) (ds:sub_typing f sg t0 t1)
: GTot (RT.sub_typing (extend_env_l f sg) (elab_ty t0) (elab_ty t1))
= match ds with
| S_Refl _ _ -> RT.Rel_equiv _ _ _ _ (RT.Rel_refl _ _ _)
| S_ELab _ _ _ d -> d
#push-options "--query_stats --fuel 8 --ifuel 2 --z3rlimit_factor 4"
let rec elab_close_commute' (n:nat) (e:src_exp) (x:var)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.ND x n ] ==
elab_exp (close_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_close_commute' n e1 x;
elab_close_commute' n e2 x
| EIf b e1 e2 ->
elab_close_commute' n b x;
elab_close_commute' n e1 x;
elab_close_commute' n e2 x
| ELam t e ->
elab_ty_close_commute' n t x;
elab_close_commute' (n + 1) e x
and elab_ty_close_commute' (n:nat) (e:src_ty) (x:var)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.ND x n ] ==
elab_ty (close_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_close_commute' n t x;
elab_ty_close_commute' (n + 1) t' x
| TRefineBool e ->
elab_close_commute' (n + 1) e x
#pop-options
let elab_ty_close_commute (e:src_ty) (x:var)
: Lemma (RT.close_term (elab_ty e) x == elab_ty (close_ty e x))
[SMTPat (RT.close_term (elab_ty e) x)]
= RT.close_term_spec (elab_ty e) x;
elab_ty_close_commute' 0 e x
let elab_ty_open_with_commute (e:src_ty) (v:src_exp)
: Lemma (RT.open_with (elab_ty e) (elab_exp v) == elab_ty (open_ty_with e v))
[SMTPat (RT.open_with (elab_ty e) (elab_exp v))]
= elab_ty_open_commute' 0 e v;
RT.open_with_spec (elab_ty e) (elab_exp v)
let elab_ty_open_commute (e:src_ty) (v:var)
: Lemma (RT.open_term (elab_ty e) v == elab_ty (open_ty e v))
[SMTPat (RT.open_term (elab_ty e) v)]
= elab_ty_open_commute' 0 e (EVar v);
RT.open_term_spec (elab_ty e) v
let elab_open_b2t (e:src_exp) (x:var)
: Lemma (RT.open_term (r_b2t (elab_exp e)) x ==
r_b2t (elab_exp (open_exp e x)))
= RT.open_term_spec (r_b2t (elab_exp e)) x;
RT.open_term_spec (elab_exp e) x
let rec soundness (#f:fstar_top_env)
(#sg:src_env { src_env_ok sg } )
(#se:src_exp)
(#st:src_ty)
(dd:src_typing f sg se st)
: GTot (RT.tot_typing (extend_env_l f sg)
(elab_exp se)
(elab_ty st))
(decreases (height dd))
= match dd with
| T_Bool _ true ->
RT.T_Const _ _ _ RT.CT_True
| T_Bool _ false ->
RT.T_Const _ _ _ RT.CT_False
| T_Var _ x ->
RT.T_Var _ (R.pack_namedv (RT.make_namedv x))
| T_Lam _ t e t' x dt de ->
let de : RT.tot_typing (extend_env_l f ((x,Inl t)::sg))
(elab_exp (open_exp e x))
(elab_ty t')
= soundness de
in
let de : RT.tot_typing (RT.extend_env (extend_env_l f sg) x (elab_ty t))
(elab_exp (open_exp e x))
(elab_ty t')
= de
in
fresh_is_fresh sg;
freevars_elab_exp e;
let dt : RT.tot_typing (extend_env_l f sg) (elab_ty t) (RT.tm_type RT.u_zero) =
src_ty_ok_soundness sg t dt
in
let dd
: RT.tot_typing (extend_env_l f sg)
(R.pack_ln (R.Tv_Abs (RT.mk_simple_binder RT.pp_name_default (elab_ty t)) (elab_exp e)))
(elab_ty (TArrow t (close_ty t' x)))
= RT.close_term_spec (elab_ty t') x;
assert (elab_ty (close_ty t' x) ==
RT.subst_term (elab_ty t') [ RT.ND x 0 ]);
RT.T_Abs (extend_env_l f sg)
x
(elab_ty t)
(elab_exp e)
(T.E_Total, elab_ty t')
_
_
_
_
dt
de
in
dd
| T_If _ b e1 e2 t1 t2 t hyp db d1 d2 s1 s2 tok ->
let db = soundness db in
let d1 = soundness d1 in
let d2 = soundness d2 in
let s1 = subtyping_soundness s1 in
let s2 = subtyping_soundness s2 in
let t_ok = src_ty_ok_soundness sg t tok in
let d1 = RT.T_Sub _ _ _ _ d1 (RT.Relc_typ _ _ _ _ _ s1) in
let d2 = RT.T_Sub _ _ _ _ d2 (RT.Relc_typ _ _ _ _ _ s2) in
freevars_elab_exp e1;
freevars_elab_exp e2;
RT.T_If (extend_env_l f sg) (elab_exp b) (elab_exp e1) (elab_exp e2) _ _ hyp _ _ db d1 d2 t_ok
| T_App _ e1 e2 t t' t0 d1 d2 st ->
let dt1
: RT.tot_typing (extend_env_l f sg)
(elab_exp e1)
(elab_ty (TArrow t t'))
= soundness d1
in
let dt2
: RT.tot_typing (extend_env_l f sg)
(elab_exp e2)
(elab_ty t0)
= soundness d2
in
let st
: RT.sub_typing (extend_env_l f sg) (elab_ty t0) (elab_ty t)
= subtyping_soundness st
in
let dt2
: RT.tot_typing (extend_env_l f sg)
(elab_exp e2)
(elab_ty t)
= RT.T_Sub _ _ _ _ dt2 (RT.Relc_typ _ _ _ _ _ st)
in
RT.T_App _ _ _ _ (elab_ty t') _ dt1 dt2
and src_ty_ok_soundness (#f:fstar_top_env)
(sg:src_env { src_env_ok sg })
(t:src_ty)
(dt:src_ty_ok f sg t)
: GTot (RT.tot_typing (extend_env_l f sg) (elab_ty t) (RT.tm_type RT.u_zero))
(decreases (t_height dt))
= match dt with
| OK_TBool _ ->
RT.T_FVar _ RT.bool_fv
| OK_TArrow _ t1 t2 x ok_t1 ok_t2 ->
let t1_ok = src_ty_ok_soundness sg _ ok_t1 in
let t2_ok = src_ty_ok_soundness ((x, Inl t1)::sg) _ ok_t2 in
freevars_elab_ty t2;
let arr_max = RT.T_Arrow _ x (elab_ty t1) (elab_ty t2) _ _ RT.pp_name_default R.Q_Explicit T.E_Total _ _ t1_ok t2_ok in
RT.simplify_umax arr_max
| OK_TRefine _ e x de ->
let de
: RT.tot_typing (RT.extend_env (extend_env_l f sg) x RT.bool_ty)
(elab_exp (open_exp e x))
(elab_ty TBool)
= soundness de
in
let de
: RT.tot_typing (RT.extend_env (extend_env_l f sg) x RT.bool_ty)
(r_b2t (elab_exp (open_exp e x)))
(RT.tm_type RT.u_zero)
= b2t_typing _ _ de
in
let bool_typing
: RT.tot_typing (extend_env_l f sg) RT.bool_ty (RT.tm_type RT.u_zero)
= RT.T_FVar _ RT.bool_fv
in
elab_open_b2t e x;
freevars_elab_exp e;
RT.T_Refine (extend_env_l f sg)
x
RT.bool_ty
(r_b2t (elab_exp e))
_ _ _ _
bool_typing
de
let soundness_lemma (f:fstar_top_env)
(sg:src_env { src_env_ok sg })
(se:src_exp)
(st:src_ty)
: Lemma
(requires src_typing f sg se st)
(ensures RT.tot_typing (extend_env_l f sg)
(elab_exp se)
(elab_ty st))
= FStar.Squash.bind_squash
#(src_typing f sg se st)
()
(fun dd -> FStar.Squash.return_squash (soundness dd)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 2,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 2,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | t: DependentBoolRefinement.src_ty
-> b: Prims.bool{b <==> FStar.Set.equal (DependentBoolRefinement.freevars_ty t) FStar.Set.empty} | Prims.Tot | [
"total"
] | [
"closed",
"closed_ty"
] | [
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.closed",
"Prims.op_AmpAmp",
"DependentBoolRefinement.closed_ty",
"Prims.bool",
"Prims.l_iff",
"Prims.b2t",
"FStar.Set.equal",
"DependentBoolRefinement.var",
"DependentBoolRefinement.freevars_ty",
"FStar.Set.empty"
] | [
"mutual recursion"
] | false | false | false | false | false | let rec closed_ty (t: src_ty) : b: bool{b <==> ((freevars_ty t) `Set.equal` Set.empty)} =
| match t with
| TBool -> true
| TRefineBool e -> closed e
| TArrow t1 t2 -> closed_ty t1 && closed_ty t2 | false |
DependentBoolRefinement.fst | DependentBoolRefinement.elab_ty_open_with_commute | val elab_ty_open_with_commute (e: src_ty) (v: src_exp)
: Lemma (RT.open_with (elab_ty e) (elab_exp v) == elab_ty (open_ty_with e v))
[SMTPat (RT.open_with (elab_ty e) (elab_exp v))] | val elab_ty_open_with_commute (e: src_ty) (v: src_exp)
: Lemma (RT.open_with (elab_ty e) (elab_exp v) == elab_ty (open_ty_with e v))
[SMTPat (RT.open_with (elab_ty e) (elab_exp v))] | let elab_ty_open_with_commute (e:src_ty) (v:src_exp)
: Lemma (RT.open_with (elab_ty e) (elab_exp v) == elab_ty (open_ty_with e v))
[SMTPat (RT.open_with (elab_ty e) (elab_exp v))]
= elab_ty_open_commute' 0 e v;
RT.open_with_spec (elab_ty e) (elab_exp v) | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 46,
"end_line": 696,
"start_col": 0,
"start_line": 692
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1
let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1
let check_sub_typing f
(sg:src_env)
(t0 t1:src_ty)
: T.Tac (sub_typing f sg t0 t1)
= if t0 = t1 then S_Refl _ t0
else T.fail "Not subtypes"
let weaken (f:fstar_top_env) (sg:src_env) (hyp:var { None? (lookup sg hyp) } ) (b:src_exp) (t0 t1:src_ty)
: T.Tac (t:src_ty &
sub_typing f ((hyp,Inr(b, EBool true))::sg) t0 t &
sub_typing f ((hyp,Inr(b, EBool false))::sg) t1 t)
= if t0 = t1
then (| t0, S_Refl _ t0, S_Refl _ t1 |)
else T.fail "weaken is very dumb"
let ok (sg:src_env) (e:src_exp) = (forall x. x `Set.mem` freevars e ==> Some? (lookup sg x))
let ok_ty (sg:src_env) (e:src_ty) = (forall x. x `Set.mem` freevars_ty e ==> Some? (lookup sg x))
let rec check_ok_ty (t:src_ty) (sg:src_env)
: b:bool { b <==> (ok_ty sg t) }
= match t with
| TBool -> true
| TArrow t1 t2 ->
check_ok_ty t1 sg &&
check_ok_ty t2 sg
| TRefineBool e ->
check_ok e sg
and check_ok (e:src_exp) (sg:src_env)
: b:bool { b <==> ok sg e }
= match e with
| EBVar _ -> true
| EVar x -> Some? (lookup sg x)
| EBool _ -> true
| EIf b e1 e2 -> check_ok b sg && check_ok e1 sg && check_ok e2 sg
| ELam t e -> check_ok_ty t sg && check_ok e sg
| EApp e1 e2 -> check_ok e1 sg && check_ok e2 sg
#push-options "--fuel 2 --ifuel 2 --z3rlimit_factor 6 --query_stats"
let rec check (f:fstar_top_env)
(sg:src_env)
(e:src_exp { ok sg e })
: T.Tac (t:src_ty &
src_typing f sg e t)
= match e with
| EBVar _ ->
T.fail "Not locally nameless"
| EBool b ->
(| TBool, T_Bool _ b |)
| EVar n ->
begin
match lookup_ty sg n with
| None -> T.fail "Ill-typed"
| Some t ->
let d = T_Var sg n in
(| t, d |)
end
| ELam t body ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars body (EVar x) 0;
let (| tbody, dbody |) = check f ((x, Inl t)::sg) (open_exp body x) in
let dd : src_typing f sg e (TArrow t (close_ty tbody x)) =
T_Lam sg t body tbody x t_ok dbody in
(| TArrow t (close_ty tbody x), dd |)
| EApp e1 e2 ->
let (| t1, d1 |) = check f sg e1 in
let (| t2, d2 |) = check f sg e2 in
begin
match t1 with
| TArrow t_arg t_res ->
let st_ok = check_sub_typing f sg t2 t_arg in
(| open_ty_with t_res e2, T_App _ _ _ t_arg t_res _ d1 d2 st_ok |)
| _ ->
T.fail "Expected a function"
end
| EIf b e1 e2 ->
let (| tb, ok_b |) = check f sg b in
let hyp = fresh sg in
fresh_is_fresh sg;
if tb = TBool
then (
let (| t1, ok_1 |) = check f ((hyp, Inr(b, EBool true))::sg) e1 in
let (| t2, ok_2 |) = check f ((hyp, Inr(b, EBool false))::sg) e2 in
let (| t, w1, w2 |) = weaken f sg hyp b t1 t2 in
if not (check_ok_ty t sg)
then T.fail "Free variable escapes scope"
else (
let t_ok = check_ty f sg t in
(| t, T_If _ _ _ _ _ _ _ hyp ok_b ok_1 ok_2 w1 w2 t_ok |)
)
)
else T.fail "Branching on a non-boolean"
and check_ty (f:fstar_top_env)
(sg:src_env)
(t:src_ty { ok_ty sg t })
: T.Tac (src_ty_ok f sg t)
= match t with
| TBool -> OK_TBool _
| TArrow t t' ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_ty_freevars t' (EVar x) 0;
let t'_ok = check_ty f ((x, Inl t)::sg) (open_ty t' x) in
OK_TArrow _ _ _ x t_ok t'_ok
| TRefineBool e ->
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars e (EVar x) 0;
let (| te, de |) = check f ((x, Inl TBool)::sg) (open_exp e x) in
match te with
| TBool -> OK_TRefine sg e x de
| _ -> T.fail "Ill-typed refinement"
#pop-options
let rec extend_env_l_lookup_bvar (g:R.env) (sg:src_env) (x:var)
: Lemma
(requires (forall x. RT.lookup_bvar g x == None))
(ensures (
match lookup sg x with
| Some b -> RT.lookup_bvar (extend_env_l g sg) x == Some (elab_binding b)
| None -> RT.lookup_bvar (extend_env_l g sg) x == None))
(decreases sg)
[SMTPat (RT.lookup_bvar (extend_env_l g sg) x)]
= match sg with
| [] -> ()
| hd :: tl -> extend_env_l_lookup_bvar g tl x
#push-options "--query_stats --fuel 8 --ifuel 2 --z3rlimit_factor 2"
let rec elab_open_commute' (n:nat) (e:src_exp) (x:src_exp)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.DT n (elab_exp x) ] ==
elab_exp (open_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| EIf b e1 e2 ->
elab_open_commute' n b x;
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| ELam t e ->
elab_ty_open_commute' n t x;
elab_open_commute' (n + 1) e x
and elab_ty_open_commute' (n:nat) (e:src_ty) (x:src_exp)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.DT n (elab_exp x) ] ==
elab_ty (open_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_open_commute' n t x;
elab_ty_open_commute' (n + 1) t' x
| TRefineBool e ->
elab_open_commute' (n + 1) e x
#pop-options
let elab_open_commute (e:src_exp) (x:var)
: Lemma (RT.open_term (elab_exp e) x == elab_exp (open_exp e x))
[SMTPat (RT.open_term (elab_exp e) x)]
= elab_open_commute' 0 e (EVar x);
RT.open_term_spec (elab_exp e) x
let b2t_typing (g:fstar_env) (t:R.term) (dt:RT.tot_typing g t RT.bool_ty)
: RT.tot_typing g (r_b2t t) (RT.tm_type RT.u_zero)
= let b2t_typing : RT.tot_typing g _ b2t_ty = RT.T_FVar g b2t_fv in
let app_ty : _ = RT.T_App _ _ _ _ (RT.tm_type RT.u_zero) _ b2t_typing dt in
RT.open_with_spec (RT.tm_type RT.u_zero) t;
app_ty
let rec extend_env_l_lookup_fvar (g:R.env) (sg:src_env) (fv:R.fv)
: Lemma
(ensures
RT.lookup_fvar (extend_env_l g sg) fv ==
RT.lookup_fvar g fv)
[SMTPat (RT.lookup_fvar (extend_env_l g sg) fv)]
= match sg with
| [] -> ()
| hd::tl -> extend_env_l_lookup_fvar g tl fv
#push-options "--query_stats --fuel 2 --ifuel 2 --z3rlimit_factor 2"
let subtyping_soundness #f (#sg:src_env) (#t0 #t1:src_ty) (ds:sub_typing f sg t0 t1)
: GTot (RT.sub_typing (extend_env_l f sg) (elab_ty t0) (elab_ty t1))
= match ds with
| S_Refl _ _ -> RT.Rel_equiv _ _ _ _ (RT.Rel_refl _ _ _)
| S_ELab _ _ _ d -> d
#push-options "--query_stats --fuel 8 --ifuel 2 --z3rlimit_factor 4"
let rec elab_close_commute' (n:nat) (e:src_exp) (x:var)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.ND x n ] ==
elab_exp (close_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_close_commute' n e1 x;
elab_close_commute' n e2 x
| EIf b e1 e2 ->
elab_close_commute' n b x;
elab_close_commute' n e1 x;
elab_close_commute' n e2 x
| ELam t e ->
elab_ty_close_commute' n t x;
elab_close_commute' (n + 1) e x
and elab_ty_close_commute' (n:nat) (e:src_ty) (x:var)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.ND x n ] ==
elab_ty (close_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_close_commute' n t x;
elab_ty_close_commute' (n + 1) t' x
| TRefineBool e ->
elab_close_commute' (n + 1) e x
#pop-options
let elab_ty_close_commute (e:src_ty) (x:var)
: Lemma (RT.close_term (elab_ty e) x == elab_ty (close_ty e x))
[SMTPat (RT.close_term (elab_ty e) x)]
= RT.close_term_spec (elab_ty e) x;
elab_ty_close_commute' 0 e x | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 2,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 2,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | e: DependentBoolRefinement.src_ty -> v: DependentBoolRefinement.src_exp
-> FStar.Pervasives.Lemma
(ensures
FStar.Reflection.Typing.open_with (DependentBoolRefinement.elab_ty e)
(DependentBoolRefinement.elab_exp v) ==
DependentBoolRefinement.elab_ty (DependentBoolRefinement.open_ty_with e v))
[
SMTPat (FStar.Reflection.Typing.open_with (DependentBoolRefinement.elab_ty e)
(DependentBoolRefinement.elab_exp v))
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.src_exp",
"FStar.Reflection.Typing.open_with_spec",
"DependentBoolRefinement.elab_ty",
"DependentBoolRefinement.elab_exp",
"Prims.unit",
"DependentBoolRefinement.elab_ty_open_commute'",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Stubs.Reflection.Types.term",
"FStar.Reflection.Typing.open_with",
"DependentBoolRefinement.open_ty_with",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | true | false | true | false | false | let elab_ty_open_with_commute (e: src_ty) (v: src_exp)
: Lemma (RT.open_with (elab_ty e) (elab_exp v) == elab_ty (open_ty_with e v))
[SMTPat (RT.open_with (elab_ty e) (elab_exp v))] =
| elab_ty_open_commute' 0 e v;
RT.open_with_spec (elab_ty e) (elab_exp v) | false |
DependentBoolRefinement.fst | DependentBoolRefinement.main | val main (nm: string) (src: src_exp) : RT.dsl_tac_t | val main (nm: string) (src: src_exp) : RT.dsl_tac_t | let main (nm:string) (src:src_exp)
: RT.dsl_tac_t
= fun f ->
if closed src
then
let (| src_ty, _ |) = check f [] src in
soundness_lemma f [] src src_ty;
[RT.mk_checked_let f nm (elab_exp src) (elab_ty src_ty)]
else T.fail "Not locally nameless" | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 40,
"end_line": 887,
"start_col": 0,
"start_line": 879
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1
let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1
let check_sub_typing f
(sg:src_env)
(t0 t1:src_ty)
: T.Tac (sub_typing f sg t0 t1)
= if t0 = t1 then S_Refl _ t0
else T.fail "Not subtypes"
let weaken (f:fstar_top_env) (sg:src_env) (hyp:var { None? (lookup sg hyp) } ) (b:src_exp) (t0 t1:src_ty)
: T.Tac (t:src_ty &
sub_typing f ((hyp,Inr(b, EBool true))::sg) t0 t &
sub_typing f ((hyp,Inr(b, EBool false))::sg) t1 t)
= if t0 = t1
then (| t0, S_Refl _ t0, S_Refl _ t1 |)
else T.fail "weaken is very dumb"
let ok (sg:src_env) (e:src_exp) = (forall x. x `Set.mem` freevars e ==> Some? (lookup sg x))
let ok_ty (sg:src_env) (e:src_ty) = (forall x. x `Set.mem` freevars_ty e ==> Some? (lookup sg x))
let rec check_ok_ty (t:src_ty) (sg:src_env)
: b:bool { b <==> (ok_ty sg t) }
= match t with
| TBool -> true
| TArrow t1 t2 ->
check_ok_ty t1 sg &&
check_ok_ty t2 sg
| TRefineBool e ->
check_ok e sg
and check_ok (e:src_exp) (sg:src_env)
: b:bool { b <==> ok sg e }
= match e with
| EBVar _ -> true
| EVar x -> Some? (lookup sg x)
| EBool _ -> true
| EIf b e1 e2 -> check_ok b sg && check_ok e1 sg && check_ok e2 sg
| ELam t e -> check_ok_ty t sg && check_ok e sg
| EApp e1 e2 -> check_ok e1 sg && check_ok e2 sg
#push-options "--fuel 2 --ifuel 2 --z3rlimit_factor 6 --query_stats"
let rec check (f:fstar_top_env)
(sg:src_env)
(e:src_exp { ok sg e })
: T.Tac (t:src_ty &
src_typing f sg e t)
= match e with
| EBVar _ ->
T.fail "Not locally nameless"
| EBool b ->
(| TBool, T_Bool _ b |)
| EVar n ->
begin
match lookup_ty sg n with
| None -> T.fail "Ill-typed"
| Some t ->
let d = T_Var sg n in
(| t, d |)
end
| ELam t body ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars body (EVar x) 0;
let (| tbody, dbody |) = check f ((x, Inl t)::sg) (open_exp body x) in
let dd : src_typing f sg e (TArrow t (close_ty tbody x)) =
T_Lam sg t body tbody x t_ok dbody in
(| TArrow t (close_ty tbody x), dd |)
| EApp e1 e2 ->
let (| t1, d1 |) = check f sg e1 in
let (| t2, d2 |) = check f sg e2 in
begin
match t1 with
| TArrow t_arg t_res ->
let st_ok = check_sub_typing f sg t2 t_arg in
(| open_ty_with t_res e2, T_App _ _ _ t_arg t_res _ d1 d2 st_ok |)
| _ ->
T.fail "Expected a function"
end
| EIf b e1 e2 ->
let (| tb, ok_b |) = check f sg b in
let hyp = fresh sg in
fresh_is_fresh sg;
if tb = TBool
then (
let (| t1, ok_1 |) = check f ((hyp, Inr(b, EBool true))::sg) e1 in
let (| t2, ok_2 |) = check f ((hyp, Inr(b, EBool false))::sg) e2 in
let (| t, w1, w2 |) = weaken f sg hyp b t1 t2 in
if not (check_ok_ty t sg)
then T.fail "Free variable escapes scope"
else (
let t_ok = check_ty f sg t in
(| t, T_If _ _ _ _ _ _ _ hyp ok_b ok_1 ok_2 w1 w2 t_ok |)
)
)
else T.fail "Branching on a non-boolean"
and check_ty (f:fstar_top_env)
(sg:src_env)
(t:src_ty { ok_ty sg t })
: T.Tac (src_ty_ok f sg t)
= match t with
| TBool -> OK_TBool _
| TArrow t t' ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_ty_freevars t' (EVar x) 0;
let t'_ok = check_ty f ((x, Inl t)::sg) (open_ty t' x) in
OK_TArrow _ _ _ x t_ok t'_ok
| TRefineBool e ->
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars e (EVar x) 0;
let (| te, de |) = check f ((x, Inl TBool)::sg) (open_exp e x) in
match te with
| TBool -> OK_TRefine sg e x de
| _ -> T.fail "Ill-typed refinement"
#pop-options
let rec extend_env_l_lookup_bvar (g:R.env) (sg:src_env) (x:var)
: Lemma
(requires (forall x. RT.lookup_bvar g x == None))
(ensures (
match lookup sg x with
| Some b -> RT.lookup_bvar (extend_env_l g sg) x == Some (elab_binding b)
| None -> RT.lookup_bvar (extend_env_l g sg) x == None))
(decreases sg)
[SMTPat (RT.lookup_bvar (extend_env_l g sg) x)]
= match sg with
| [] -> ()
| hd :: tl -> extend_env_l_lookup_bvar g tl x
#push-options "--query_stats --fuel 8 --ifuel 2 --z3rlimit_factor 2"
let rec elab_open_commute' (n:nat) (e:src_exp) (x:src_exp)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.DT n (elab_exp x) ] ==
elab_exp (open_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| EIf b e1 e2 ->
elab_open_commute' n b x;
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| ELam t e ->
elab_ty_open_commute' n t x;
elab_open_commute' (n + 1) e x
and elab_ty_open_commute' (n:nat) (e:src_ty) (x:src_exp)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.DT n (elab_exp x) ] ==
elab_ty (open_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_open_commute' n t x;
elab_ty_open_commute' (n + 1) t' x
| TRefineBool e ->
elab_open_commute' (n + 1) e x
#pop-options
let elab_open_commute (e:src_exp) (x:var)
: Lemma (RT.open_term (elab_exp e) x == elab_exp (open_exp e x))
[SMTPat (RT.open_term (elab_exp e) x)]
= elab_open_commute' 0 e (EVar x);
RT.open_term_spec (elab_exp e) x
let b2t_typing (g:fstar_env) (t:R.term) (dt:RT.tot_typing g t RT.bool_ty)
: RT.tot_typing g (r_b2t t) (RT.tm_type RT.u_zero)
= let b2t_typing : RT.tot_typing g _ b2t_ty = RT.T_FVar g b2t_fv in
let app_ty : _ = RT.T_App _ _ _ _ (RT.tm_type RT.u_zero) _ b2t_typing dt in
RT.open_with_spec (RT.tm_type RT.u_zero) t;
app_ty
let rec extend_env_l_lookup_fvar (g:R.env) (sg:src_env) (fv:R.fv)
: Lemma
(ensures
RT.lookup_fvar (extend_env_l g sg) fv ==
RT.lookup_fvar g fv)
[SMTPat (RT.lookup_fvar (extend_env_l g sg) fv)]
= match sg with
| [] -> ()
| hd::tl -> extend_env_l_lookup_fvar g tl fv
#push-options "--query_stats --fuel 2 --ifuel 2 --z3rlimit_factor 2"
let subtyping_soundness #f (#sg:src_env) (#t0 #t1:src_ty) (ds:sub_typing f sg t0 t1)
: GTot (RT.sub_typing (extend_env_l f sg) (elab_ty t0) (elab_ty t1))
= match ds with
| S_Refl _ _ -> RT.Rel_equiv _ _ _ _ (RT.Rel_refl _ _ _)
| S_ELab _ _ _ d -> d
#push-options "--query_stats --fuel 8 --ifuel 2 --z3rlimit_factor 4"
let rec elab_close_commute' (n:nat) (e:src_exp) (x:var)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.ND x n ] ==
elab_exp (close_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_close_commute' n e1 x;
elab_close_commute' n e2 x
| EIf b e1 e2 ->
elab_close_commute' n b x;
elab_close_commute' n e1 x;
elab_close_commute' n e2 x
| ELam t e ->
elab_ty_close_commute' n t x;
elab_close_commute' (n + 1) e x
and elab_ty_close_commute' (n:nat) (e:src_ty) (x:var)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.ND x n ] ==
elab_ty (close_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_close_commute' n t x;
elab_ty_close_commute' (n + 1) t' x
| TRefineBool e ->
elab_close_commute' (n + 1) e x
#pop-options
let elab_ty_close_commute (e:src_ty) (x:var)
: Lemma (RT.close_term (elab_ty e) x == elab_ty (close_ty e x))
[SMTPat (RT.close_term (elab_ty e) x)]
= RT.close_term_spec (elab_ty e) x;
elab_ty_close_commute' 0 e x
let elab_ty_open_with_commute (e:src_ty) (v:src_exp)
: Lemma (RT.open_with (elab_ty e) (elab_exp v) == elab_ty (open_ty_with e v))
[SMTPat (RT.open_with (elab_ty e) (elab_exp v))]
= elab_ty_open_commute' 0 e v;
RT.open_with_spec (elab_ty e) (elab_exp v)
let elab_ty_open_commute (e:src_ty) (v:var)
: Lemma (RT.open_term (elab_ty e) v == elab_ty (open_ty e v))
[SMTPat (RT.open_term (elab_ty e) v)]
= elab_ty_open_commute' 0 e (EVar v);
RT.open_term_spec (elab_ty e) v
let elab_open_b2t (e:src_exp) (x:var)
: Lemma (RT.open_term (r_b2t (elab_exp e)) x ==
r_b2t (elab_exp (open_exp e x)))
= RT.open_term_spec (r_b2t (elab_exp e)) x;
RT.open_term_spec (elab_exp e) x
let rec soundness (#f:fstar_top_env)
(#sg:src_env { src_env_ok sg } )
(#se:src_exp)
(#st:src_ty)
(dd:src_typing f sg se st)
: GTot (RT.tot_typing (extend_env_l f sg)
(elab_exp se)
(elab_ty st))
(decreases (height dd))
= match dd with
| T_Bool _ true ->
RT.T_Const _ _ _ RT.CT_True
| T_Bool _ false ->
RT.T_Const _ _ _ RT.CT_False
| T_Var _ x ->
RT.T_Var _ (R.pack_namedv (RT.make_namedv x))
| T_Lam _ t e t' x dt de ->
let de : RT.tot_typing (extend_env_l f ((x,Inl t)::sg))
(elab_exp (open_exp e x))
(elab_ty t')
= soundness de
in
let de : RT.tot_typing (RT.extend_env (extend_env_l f sg) x (elab_ty t))
(elab_exp (open_exp e x))
(elab_ty t')
= de
in
fresh_is_fresh sg;
freevars_elab_exp e;
let dt : RT.tot_typing (extend_env_l f sg) (elab_ty t) (RT.tm_type RT.u_zero) =
src_ty_ok_soundness sg t dt
in
let dd
: RT.tot_typing (extend_env_l f sg)
(R.pack_ln (R.Tv_Abs (RT.mk_simple_binder RT.pp_name_default (elab_ty t)) (elab_exp e)))
(elab_ty (TArrow t (close_ty t' x)))
= RT.close_term_spec (elab_ty t') x;
assert (elab_ty (close_ty t' x) ==
RT.subst_term (elab_ty t') [ RT.ND x 0 ]);
RT.T_Abs (extend_env_l f sg)
x
(elab_ty t)
(elab_exp e)
(T.E_Total, elab_ty t')
_
_
_
_
dt
de
in
dd
| T_If _ b e1 e2 t1 t2 t hyp db d1 d2 s1 s2 tok ->
let db = soundness db in
let d1 = soundness d1 in
let d2 = soundness d2 in
let s1 = subtyping_soundness s1 in
let s2 = subtyping_soundness s2 in
let t_ok = src_ty_ok_soundness sg t tok in
let d1 = RT.T_Sub _ _ _ _ d1 (RT.Relc_typ _ _ _ _ _ s1) in
let d2 = RT.T_Sub _ _ _ _ d2 (RT.Relc_typ _ _ _ _ _ s2) in
freevars_elab_exp e1;
freevars_elab_exp e2;
RT.T_If (extend_env_l f sg) (elab_exp b) (elab_exp e1) (elab_exp e2) _ _ hyp _ _ db d1 d2 t_ok
| T_App _ e1 e2 t t' t0 d1 d2 st ->
let dt1
: RT.tot_typing (extend_env_l f sg)
(elab_exp e1)
(elab_ty (TArrow t t'))
= soundness d1
in
let dt2
: RT.tot_typing (extend_env_l f sg)
(elab_exp e2)
(elab_ty t0)
= soundness d2
in
let st
: RT.sub_typing (extend_env_l f sg) (elab_ty t0) (elab_ty t)
= subtyping_soundness st
in
let dt2
: RT.tot_typing (extend_env_l f sg)
(elab_exp e2)
(elab_ty t)
= RT.T_Sub _ _ _ _ dt2 (RT.Relc_typ _ _ _ _ _ st)
in
RT.T_App _ _ _ _ (elab_ty t') _ dt1 dt2
and src_ty_ok_soundness (#f:fstar_top_env)
(sg:src_env { src_env_ok sg })
(t:src_ty)
(dt:src_ty_ok f sg t)
: GTot (RT.tot_typing (extend_env_l f sg) (elab_ty t) (RT.tm_type RT.u_zero))
(decreases (t_height dt))
= match dt with
| OK_TBool _ ->
RT.T_FVar _ RT.bool_fv
| OK_TArrow _ t1 t2 x ok_t1 ok_t2 ->
let t1_ok = src_ty_ok_soundness sg _ ok_t1 in
let t2_ok = src_ty_ok_soundness ((x, Inl t1)::sg) _ ok_t2 in
freevars_elab_ty t2;
let arr_max = RT.T_Arrow _ x (elab_ty t1) (elab_ty t2) _ _ RT.pp_name_default R.Q_Explicit T.E_Total _ _ t1_ok t2_ok in
RT.simplify_umax arr_max
| OK_TRefine _ e x de ->
let de
: RT.tot_typing (RT.extend_env (extend_env_l f sg) x RT.bool_ty)
(elab_exp (open_exp e x))
(elab_ty TBool)
= soundness de
in
let de
: RT.tot_typing (RT.extend_env (extend_env_l f sg) x RT.bool_ty)
(r_b2t (elab_exp (open_exp e x)))
(RT.tm_type RT.u_zero)
= b2t_typing _ _ de
in
let bool_typing
: RT.tot_typing (extend_env_l f sg) RT.bool_ty (RT.tm_type RT.u_zero)
= RT.T_FVar _ RT.bool_fv
in
elab_open_b2t e x;
freevars_elab_exp e;
RT.T_Refine (extend_env_l f sg)
x
RT.bool_ty
(r_b2t (elab_exp e))
_ _ _ _
bool_typing
de
let soundness_lemma (f:fstar_top_env)
(sg:src_env { src_env_ok sg })
(se:src_exp)
(st:src_ty)
: Lemma
(requires src_typing f sg se st)
(ensures RT.tot_typing (extend_env_l f sg)
(elab_exp se)
(elab_ty st))
= FStar.Squash.bind_squash
#(src_typing f sg se st)
()
(fun dd -> FStar.Squash.return_squash (soundness dd))
let rec closed (s:src_exp)
: b:bool { b <==> (freevars s `Set.equal` Set.empty) }
= match s with
| EBool _
| EBVar _ -> true
| EVar m -> assert (m `Set.mem` freevars s); false
| EIf b e1 e2 -> closed b && closed e1 && closed e2
| ELam t e -> closed_ty t && closed e
| EApp e1 e2 -> closed e1 && closed e2
and closed_ty (t:src_ty)
: b:bool { b <==> (freevars_ty t `Set.equal` Set.empty) }
= match t with
| TBool -> true
| TRefineBool e -> closed e
| TArrow t1 t2 -> closed_ty t1 && closed_ty t2 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 2,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 2,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | nm: Prims.string -> src: DependentBoolRefinement.src_exp -> FStar.Reflection.Typing.dsl_tac_t | Prims.Tot | [
"total"
] | [] | [
"Prims.string",
"DependentBoolRefinement.src_exp",
"FStar.Reflection.Typing.fstar_top_env",
"DependentBoolRefinement.closed",
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.src_typing",
"Prims.Nil",
"FStar.Pervasives.Native.tuple2",
"DependentBoolRefinement.var",
"DependentBoolRefinement.binding",
"Prims.Cons",
"FStar.Reflection.Typing.sigelt_for",
"FStar.Reflection.Typing.dsl_tac_result_t",
"FStar.Reflection.Typing.mk_checked_let",
"DependentBoolRefinement.elab_exp",
"DependentBoolRefinement.elab_ty",
"Prims.unit",
"DependentBoolRefinement.soundness_lemma",
"Prims.dtuple2",
"DependentBoolRefinement.check",
"Prims.bool",
"FStar.Tactics.V2.Derived.fail",
"FStar.Reflection.Typing.dsl_tac_t"
] | [] | false | false | false | true | false | let main (nm: string) (src: src_exp) : RT.dsl_tac_t =
| fun f ->
if closed src
then
let (| src_ty , _ |) = check f [] src in
soundness_lemma f [] src src_ty;
[RT.mk_checked_let f nm (elab_exp src) (elab_ty src_ty)]
else T.fail "Not locally nameless" | false |
DependentBoolRefinement.fst | DependentBoolRefinement.check_ok_ty | val check_ok_ty (t: src_ty) (sg: src_env) : b: bool{b <==> (ok_ty sg t)} | val check_ok_ty (t: src_ty) (sg: src_env) : b: bool{b <==> (ok_ty sg t)} | let rec check_ok_ty (t:src_ty) (sg:src_env)
: b:bool { b <==> (ok_ty sg t) }
= match t with
| TBool -> true
| TArrow t1 t2 ->
check_ok_ty t1 sg &&
check_ok_ty t2 sg
| TRefineBool e ->
check_ok e sg
and check_ok (e:src_exp) (sg:src_env)
: b:bool { b <==> ok sg e }
= match e with
| EBVar _ -> true
| EVar x -> Some? (lookup sg x)
| EBool _ -> true
| EIf b e1 e2 -> check_ok b sg && check_ok e1 sg && check_ok e2 sg
| ELam t e -> check_ok_ty t sg && check_ok e sg
| EApp e1 e2 -> check_ok e1 sg && check_ok e2 sg | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 52,
"end_line": 472,
"start_col": 0,
"start_line": 455
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1
let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1
let check_sub_typing f
(sg:src_env)
(t0 t1:src_ty)
: T.Tac (sub_typing f sg t0 t1)
= if t0 = t1 then S_Refl _ t0
else T.fail "Not subtypes"
let weaken (f:fstar_top_env) (sg:src_env) (hyp:var { None? (lookup sg hyp) } ) (b:src_exp) (t0 t1:src_ty)
: T.Tac (t:src_ty &
sub_typing f ((hyp,Inr(b, EBool true))::sg) t0 t &
sub_typing f ((hyp,Inr(b, EBool false))::sg) t1 t)
= if t0 = t1
then (| t0, S_Refl _ t0, S_Refl _ t1 |)
else T.fail "weaken is very dumb"
let ok (sg:src_env) (e:src_exp) = (forall x. x `Set.mem` freevars e ==> Some? (lookup sg x))
let ok_ty (sg:src_env) (e:src_ty) = (forall x. x `Set.mem` freevars_ty e ==> Some? (lookup sg x)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | t: DependentBoolRefinement.src_ty -> sg: DependentBoolRefinement.src_env
-> b: Prims.bool{b <==> DependentBoolRefinement.ok_ty sg t} | Prims.Tot | [
"total"
] | [
"check_ok_ty",
"check_ok"
] | [
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.src_env",
"Prims.op_AmpAmp",
"DependentBoolRefinement.check_ok_ty",
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.check_ok",
"Prims.bool",
"Prims.l_iff",
"Prims.b2t",
"DependentBoolRefinement.ok_ty"
] | [
"mutual recursion"
] | false | false | false | false | false | let rec check_ok_ty (t: src_ty) (sg: src_env) : b: bool{b <==> (ok_ty sg t)} =
| match t with
| TBool -> true
| TArrow t1 t2 -> check_ok_ty t1 sg && check_ok_ty t2 sg
| TRefineBool e -> check_ok e sg | false |
DependentBoolRefinement.fst | DependentBoolRefinement.closed | val closed (s: src_exp) : b: bool{b <==> ((freevars s) `Set.equal` Set.empty)} | val closed (s: src_exp) : b: bool{b <==> ((freevars s) `Set.equal` Set.empty)} | let rec closed (s:src_exp)
: b:bool { b <==> (freevars s `Set.equal` Set.empty) }
= match s with
| EBool _
| EBVar _ -> true
| EVar m -> assert (m `Set.mem` freevars s); false
| EIf b e1 e2 -> closed b && closed e1 && closed e2
| ELam t e -> closed_ty t && closed e
| EApp e1 e2 -> closed e1 && closed e2
and closed_ty (t:src_ty)
: b:bool { b <==> (freevars_ty t `Set.equal` Set.empty) }
= match t with
| TBool -> true
| TRefineBool e -> closed e
| TArrow t1 t2 -> closed_ty t1 && closed_ty t2 | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 50,
"end_line": 877,
"start_col": 0,
"start_line": 862
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1
let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1
let check_sub_typing f
(sg:src_env)
(t0 t1:src_ty)
: T.Tac (sub_typing f sg t0 t1)
= if t0 = t1 then S_Refl _ t0
else T.fail "Not subtypes"
let weaken (f:fstar_top_env) (sg:src_env) (hyp:var { None? (lookup sg hyp) } ) (b:src_exp) (t0 t1:src_ty)
: T.Tac (t:src_ty &
sub_typing f ((hyp,Inr(b, EBool true))::sg) t0 t &
sub_typing f ((hyp,Inr(b, EBool false))::sg) t1 t)
= if t0 = t1
then (| t0, S_Refl _ t0, S_Refl _ t1 |)
else T.fail "weaken is very dumb"
let ok (sg:src_env) (e:src_exp) = (forall x. x `Set.mem` freevars e ==> Some? (lookup sg x))
let ok_ty (sg:src_env) (e:src_ty) = (forall x. x `Set.mem` freevars_ty e ==> Some? (lookup sg x))
let rec check_ok_ty (t:src_ty) (sg:src_env)
: b:bool { b <==> (ok_ty sg t) }
= match t with
| TBool -> true
| TArrow t1 t2 ->
check_ok_ty t1 sg &&
check_ok_ty t2 sg
| TRefineBool e ->
check_ok e sg
and check_ok (e:src_exp) (sg:src_env)
: b:bool { b <==> ok sg e }
= match e with
| EBVar _ -> true
| EVar x -> Some? (lookup sg x)
| EBool _ -> true
| EIf b e1 e2 -> check_ok b sg && check_ok e1 sg && check_ok e2 sg
| ELam t e -> check_ok_ty t sg && check_ok e sg
| EApp e1 e2 -> check_ok e1 sg && check_ok e2 sg
#push-options "--fuel 2 --ifuel 2 --z3rlimit_factor 6 --query_stats"
let rec check (f:fstar_top_env)
(sg:src_env)
(e:src_exp { ok sg e })
: T.Tac (t:src_ty &
src_typing f sg e t)
= match e with
| EBVar _ ->
T.fail "Not locally nameless"
| EBool b ->
(| TBool, T_Bool _ b |)
| EVar n ->
begin
match lookup_ty sg n with
| None -> T.fail "Ill-typed"
| Some t ->
let d = T_Var sg n in
(| t, d |)
end
| ELam t body ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars body (EVar x) 0;
let (| tbody, dbody |) = check f ((x, Inl t)::sg) (open_exp body x) in
let dd : src_typing f sg e (TArrow t (close_ty tbody x)) =
T_Lam sg t body tbody x t_ok dbody in
(| TArrow t (close_ty tbody x), dd |)
| EApp e1 e2 ->
let (| t1, d1 |) = check f sg e1 in
let (| t2, d2 |) = check f sg e2 in
begin
match t1 with
| TArrow t_arg t_res ->
let st_ok = check_sub_typing f sg t2 t_arg in
(| open_ty_with t_res e2, T_App _ _ _ t_arg t_res _ d1 d2 st_ok |)
| _ ->
T.fail "Expected a function"
end
| EIf b e1 e2 ->
let (| tb, ok_b |) = check f sg b in
let hyp = fresh sg in
fresh_is_fresh sg;
if tb = TBool
then (
let (| t1, ok_1 |) = check f ((hyp, Inr(b, EBool true))::sg) e1 in
let (| t2, ok_2 |) = check f ((hyp, Inr(b, EBool false))::sg) e2 in
let (| t, w1, w2 |) = weaken f sg hyp b t1 t2 in
if not (check_ok_ty t sg)
then T.fail "Free variable escapes scope"
else (
let t_ok = check_ty f sg t in
(| t, T_If _ _ _ _ _ _ _ hyp ok_b ok_1 ok_2 w1 w2 t_ok |)
)
)
else T.fail "Branching on a non-boolean"
and check_ty (f:fstar_top_env)
(sg:src_env)
(t:src_ty { ok_ty sg t })
: T.Tac (src_ty_ok f sg t)
= match t with
| TBool -> OK_TBool _
| TArrow t t' ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_ty_freevars t' (EVar x) 0;
let t'_ok = check_ty f ((x, Inl t)::sg) (open_ty t' x) in
OK_TArrow _ _ _ x t_ok t'_ok
| TRefineBool e ->
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars e (EVar x) 0;
let (| te, de |) = check f ((x, Inl TBool)::sg) (open_exp e x) in
match te with
| TBool -> OK_TRefine sg e x de
| _ -> T.fail "Ill-typed refinement"
#pop-options
let rec extend_env_l_lookup_bvar (g:R.env) (sg:src_env) (x:var)
: Lemma
(requires (forall x. RT.lookup_bvar g x == None))
(ensures (
match lookup sg x with
| Some b -> RT.lookup_bvar (extend_env_l g sg) x == Some (elab_binding b)
| None -> RT.lookup_bvar (extend_env_l g sg) x == None))
(decreases sg)
[SMTPat (RT.lookup_bvar (extend_env_l g sg) x)]
= match sg with
| [] -> ()
| hd :: tl -> extend_env_l_lookup_bvar g tl x
#push-options "--query_stats --fuel 8 --ifuel 2 --z3rlimit_factor 2"
let rec elab_open_commute' (n:nat) (e:src_exp) (x:src_exp)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.DT n (elab_exp x) ] ==
elab_exp (open_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| EIf b e1 e2 ->
elab_open_commute' n b x;
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| ELam t e ->
elab_ty_open_commute' n t x;
elab_open_commute' (n + 1) e x
and elab_ty_open_commute' (n:nat) (e:src_ty) (x:src_exp)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.DT n (elab_exp x) ] ==
elab_ty (open_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_open_commute' n t x;
elab_ty_open_commute' (n + 1) t' x
| TRefineBool e ->
elab_open_commute' (n + 1) e x
#pop-options
let elab_open_commute (e:src_exp) (x:var)
: Lemma (RT.open_term (elab_exp e) x == elab_exp (open_exp e x))
[SMTPat (RT.open_term (elab_exp e) x)]
= elab_open_commute' 0 e (EVar x);
RT.open_term_spec (elab_exp e) x
let b2t_typing (g:fstar_env) (t:R.term) (dt:RT.tot_typing g t RT.bool_ty)
: RT.tot_typing g (r_b2t t) (RT.tm_type RT.u_zero)
= let b2t_typing : RT.tot_typing g _ b2t_ty = RT.T_FVar g b2t_fv in
let app_ty : _ = RT.T_App _ _ _ _ (RT.tm_type RT.u_zero) _ b2t_typing dt in
RT.open_with_spec (RT.tm_type RT.u_zero) t;
app_ty
let rec extend_env_l_lookup_fvar (g:R.env) (sg:src_env) (fv:R.fv)
: Lemma
(ensures
RT.lookup_fvar (extend_env_l g sg) fv ==
RT.lookup_fvar g fv)
[SMTPat (RT.lookup_fvar (extend_env_l g sg) fv)]
= match sg with
| [] -> ()
| hd::tl -> extend_env_l_lookup_fvar g tl fv
#push-options "--query_stats --fuel 2 --ifuel 2 --z3rlimit_factor 2"
let subtyping_soundness #f (#sg:src_env) (#t0 #t1:src_ty) (ds:sub_typing f sg t0 t1)
: GTot (RT.sub_typing (extend_env_l f sg) (elab_ty t0) (elab_ty t1))
= match ds with
| S_Refl _ _ -> RT.Rel_equiv _ _ _ _ (RT.Rel_refl _ _ _)
| S_ELab _ _ _ d -> d
#push-options "--query_stats --fuel 8 --ifuel 2 --z3rlimit_factor 4"
let rec elab_close_commute' (n:nat) (e:src_exp) (x:var)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.ND x n ] ==
elab_exp (close_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_close_commute' n e1 x;
elab_close_commute' n e2 x
| EIf b e1 e2 ->
elab_close_commute' n b x;
elab_close_commute' n e1 x;
elab_close_commute' n e2 x
| ELam t e ->
elab_ty_close_commute' n t x;
elab_close_commute' (n + 1) e x
and elab_ty_close_commute' (n:nat) (e:src_ty) (x:var)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.ND x n ] ==
elab_ty (close_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_close_commute' n t x;
elab_ty_close_commute' (n + 1) t' x
| TRefineBool e ->
elab_close_commute' (n + 1) e x
#pop-options
let elab_ty_close_commute (e:src_ty) (x:var)
: Lemma (RT.close_term (elab_ty e) x == elab_ty (close_ty e x))
[SMTPat (RT.close_term (elab_ty e) x)]
= RT.close_term_spec (elab_ty e) x;
elab_ty_close_commute' 0 e x
let elab_ty_open_with_commute (e:src_ty) (v:src_exp)
: Lemma (RT.open_with (elab_ty e) (elab_exp v) == elab_ty (open_ty_with e v))
[SMTPat (RT.open_with (elab_ty e) (elab_exp v))]
= elab_ty_open_commute' 0 e v;
RT.open_with_spec (elab_ty e) (elab_exp v)
let elab_ty_open_commute (e:src_ty) (v:var)
: Lemma (RT.open_term (elab_ty e) v == elab_ty (open_ty e v))
[SMTPat (RT.open_term (elab_ty e) v)]
= elab_ty_open_commute' 0 e (EVar v);
RT.open_term_spec (elab_ty e) v
let elab_open_b2t (e:src_exp) (x:var)
: Lemma (RT.open_term (r_b2t (elab_exp e)) x ==
r_b2t (elab_exp (open_exp e x)))
= RT.open_term_spec (r_b2t (elab_exp e)) x;
RT.open_term_spec (elab_exp e) x
let rec soundness (#f:fstar_top_env)
(#sg:src_env { src_env_ok sg } )
(#se:src_exp)
(#st:src_ty)
(dd:src_typing f sg se st)
: GTot (RT.tot_typing (extend_env_l f sg)
(elab_exp se)
(elab_ty st))
(decreases (height dd))
= match dd with
| T_Bool _ true ->
RT.T_Const _ _ _ RT.CT_True
| T_Bool _ false ->
RT.T_Const _ _ _ RT.CT_False
| T_Var _ x ->
RT.T_Var _ (R.pack_namedv (RT.make_namedv x))
| T_Lam _ t e t' x dt de ->
let de : RT.tot_typing (extend_env_l f ((x,Inl t)::sg))
(elab_exp (open_exp e x))
(elab_ty t')
= soundness de
in
let de : RT.tot_typing (RT.extend_env (extend_env_l f sg) x (elab_ty t))
(elab_exp (open_exp e x))
(elab_ty t')
= de
in
fresh_is_fresh sg;
freevars_elab_exp e;
let dt : RT.tot_typing (extend_env_l f sg) (elab_ty t) (RT.tm_type RT.u_zero) =
src_ty_ok_soundness sg t dt
in
let dd
: RT.tot_typing (extend_env_l f sg)
(R.pack_ln (R.Tv_Abs (RT.mk_simple_binder RT.pp_name_default (elab_ty t)) (elab_exp e)))
(elab_ty (TArrow t (close_ty t' x)))
= RT.close_term_spec (elab_ty t') x;
assert (elab_ty (close_ty t' x) ==
RT.subst_term (elab_ty t') [ RT.ND x 0 ]);
RT.T_Abs (extend_env_l f sg)
x
(elab_ty t)
(elab_exp e)
(T.E_Total, elab_ty t')
_
_
_
_
dt
de
in
dd
| T_If _ b e1 e2 t1 t2 t hyp db d1 d2 s1 s2 tok ->
let db = soundness db in
let d1 = soundness d1 in
let d2 = soundness d2 in
let s1 = subtyping_soundness s1 in
let s2 = subtyping_soundness s2 in
let t_ok = src_ty_ok_soundness sg t tok in
let d1 = RT.T_Sub _ _ _ _ d1 (RT.Relc_typ _ _ _ _ _ s1) in
let d2 = RT.T_Sub _ _ _ _ d2 (RT.Relc_typ _ _ _ _ _ s2) in
freevars_elab_exp e1;
freevars_elab_exp e2;
RT.T_If (extend_env_l f sg) (elab_exp b) (elab_exp e1) (elab_exp e2) _ _ hyp _ _ db d1 d2 t_ok
| T_App _ e1 e2 t t' t0 d1 d2 st ->
let dt1
: RT.tot_typing (extend_env_l f sg)
(elab_exp e1)
(elab_ty (TArrow t t'))
= soundness d1
in
let dt2
: RT.tot_typing (extend_env_l f sg)
(elab_exp e2)
(elab_ty t0)
= soundness d2
in
let st
: RT.sub_typing (extend_env_l f sg) (elab_ty t0) (elab_ty t)
= subtyping_soundness st
in
let dt2
: RT.tot_typing (extend_env_l f sg)
(elab_exp e2)
(elab_ty t)
= RT.T_Sub _ _ _ _ dt2 (RT.Relc_typ _ _ _ _ _ st)
in
RT.T_App _ _ _ _ (elab_ty t') _ dt1 dt2
and src_ty_ok_soundness (#f:fstar_top_env)
(sg:src_env { src_env_ok sg })
(t:src_ty)
(dt:src_ty_ok f sg t)
: GTot (RT.tot_typing (extend_env_l f sg) (elab_ty t) (RT.tm_type RT.u_zero))
(decreases (t_height dt))
= match dt with
| OK_TBool _ ->
RT.T_FVar _ RT.bool_fv
| OK_TArrow _ t1 t2 x ok_t1 ok_t2 ->
let t1_ok = src_ty_ok_soundness sg _ ok_t1 in
let t2_ok = src_ty_ok_soundness ((x, Inl t1)::sg) _ ok_t2 in
freevars_elab_ty t2;
let arr_max = RT.T_Arrow _ x (elab_ty t1) (elab_ty t2) _ _ RT.pp_name_default R.Q_Explicit T.E_Total _ _ t1_ok t2_ok in
RT.simplify_umax arr_max
| OK_TRefine _ e x de ->
let de
: RT.tot_typing (RT.extend_env (extend_env_l f sg) x RT.bool_ty)
(elab_exp (open_exp e x))
(elab_ty TBool)
= soundness de
in
let de
: RT.tot_typing (RT.extend_env (extend_env_l f sg) x RT.bool_ty)
(r_b2t (elab_exp (open_exp e x)))
(RT.tm_type RT.u_zero)
= b2t_typing _ _ de
in
let bool_typing
: RT.tot_typing (extend_env_l f sg) RT.bool_ty (RT.tm_type RT.u_zero)
= RT.T_FVar _ RT.bool_fv
in
elab_open_b2t e x;
freevars_elab_exp e;
RT.T_Refine (extend_env_l f sg)
x
RT.bool_ty
(r_b2t (elab_exp e))
_ _ _ _
bool_typing
de
let soundness_lemma (f:fstar_top_env)
(sg:src_env { src_env_ok sg })
(se:src_exp)
(st:src_ty)
: Lemma
(requires src_typing f sg se st)
(ensures RT.tot_typing (extend_env_l f sg)
(elab_exp se)
(elab_ty st))
= FStar.Squash.bind_squash
#(src_typing f sg se st)
()
(fun dd -> FStar.Squash.return_squash (soundness dd)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 2,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 2,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s: DependentBoolRefinement.src_exp
-> b: Prims.bool{b <==> FStar.Set.equal (DependentBoolRefinement.freevars s) FStar.Set.empty} | Prims.Tot | [
"total"
] | [
"closed",
"closed_ty"
] | [
"DependentBoolRefinement.src_exp",
"Prims.bool",
"DependentBoolRefinement.index",
"DependentBoolRefinement.var",
"Prims.unit",
"Prims._assert",
"Prims.b2t",
"FStar.Set.mem",
"DependentBoolRefinement.freevars",
"Prims.op_AmpAmp",
"DependentBoolRefinement.closed",
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.closed_ty",
"Prims.l_iff",
"FStar.Set.equal",
"FStar.Set.empty"
] | [
"mutual recursion"
] | false | false | false | false | false | let rec closed (s: src_exp) : b: bool{b <==> ((freevars s) `Set.equal` Set.empty)} =
| match s with
| EBool _ | EBVar _ -> true
| EVar m ->
assert (m `Set.mem` (freevars s));
false
| EIf b e1 e2 -> closed b && closed e1 && closed e2
| ELam t e -> closed_ty t && closed e
| EApp e1 e2 -> closed e1 && closed e2 | false |
RecordWithRefs.fst | RecordWithRefs.u8_pair_repr | val u8_pair_repr : Type0 | let u8_pair_repr = (U8.t & U8.t) | {
"file_name": "share/steel/examples/pulse/bug-reports/RecordWithRefs.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 32,
"end_line": 28,
"start_col": 0,
"start_line": 28
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module RecordWithRefs
open Pulse.Lib.Pervasives
module U8 = FStar.UInt8
module R = Pulse.Lib.Reference
noeq
type u8_pair = {
a: ref U8.t;
b: ref U8.t
} | {
"checked_file": "/",
"dependencies": [
"Pulse.Lib.Reference.fsti.checked",
"Pulse.Lib.Pervasives.fst.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "RecordWithRefs.fst"
} | [
{
"abbrev": true,
"full_module": "Pulse.Lib.Reference",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Native.tuple2",
"FStar.UInt8.t"
] | [] | false | false | false | true | true | let u8_pair_repr =
| (U8.t & U8.t) | false |
|
RecordWithRefs.fst | RecordWithRefs.fst | val fst (p: u8_pair_repr) : U8.t | val fst (p: u8_pair_repr) : U8.t | let fst (p:u8_pair_repr) : U8.t =
let (x, _) = p in x | {
"file_name": "share/steel/examples/pulse/bug-reports/RecordWithRefs.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 21,
"end_line": 31,
"start_col": 0,
"start_line": 30
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module RecordWithRefs
open Pulse.Lib.Pervasives
module U8 = FStar.UInt8
module R = Pulse.Lib.Reference
noeq
type u8_pair = {
a: ref U8.t;
b: ref U8.t
}
let u8_pair_repr = (U8.t & U8.t) | {
"checked_file": "/",
"dependencies": [
"Pulse.Lib.Reference.fsti.checked",
"Pulse.Lib.Pervasives.fst.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "RecordWithRefs.fst"
} | [
{
"abbrev": true,
"full_module": "Pulse.Lib.Reference",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p: RecordWithRefs.u8_pair_repr -> FStar.UInt8.t | Prims.Tot | [
"total"
] | [] | [
"RecordWithRefs.u8_pair_repr",
"FStar.UInt8.t"
] | [] | false | false | false | true | false | let fst (p: u8_pair_repr) : U8.t =
| let x, _ = p in
x | false |
Hacl.Spec.K256.Field52.Lemmas.fst | Hacl.Spec.K256.Field52.Lemmas.normalize5_lemma | val normalize5_lemma: m:scale64_5 -> f:felem5 -> Lemma
(requires (let (m0,m1,m2,m3,m4) = m in
m0 + 1 <= 4096 /\ m1 + 1 <= 4096 /\
m2 + 1 <= 4096 /\ m3 + 1 <= 4096 /\
felem_fits5 f m))
(ensures (let r = normalize5 f in
as_nat5 r == as_nat5 f % S.prime /\
felem_fits5 r (1,1,1,1,1))) | val normalize5_lemma: m:scale64_5 -> f:felem5 -> Lemma
(requires (let (m0,m1,m2,m3,m4) = m in
m0 + 1 <= 4096 /\ m1 + 1 <= 4096 /\
m2 + 1 <= 4096 /\ m3 + 1 <= 4096 /\
felem_fits5 f m))
(ensures (let r = normalize5 f in
as_nat5 r == as_nat5 f % S.prime /\
felem_fits5 r (1,1,1,1,1))) | let normalize5_lemma m f =
L2.normalize5_lemma m f | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 25,
"end_line": 90,
"start_col": 0,
"start_line": 89
} | module Hacl.Spec.K256.Field52.Lemmas
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
include Hacl.Spec.K256.Field52.Definitions
include Hacl.Spec.K256.Field52
module ML = Hacl.Spec.K256.MathLemmas
module LD = Hacl.Spec.K256.Field52.Definitions.Lemmas
module L1 = Hacl.Spec.K256.Field52.Lemmas1
module L2 = Hacl.Spec.K256.Field52.Lemmas2
module L3 = Hacl.Spec.K256.Field52.Lemmas3
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let load_felem5_lemma s =
L1.load_felem5_lemma s
let store_felem5_lemma f =
L1.store_felem5_lemma f
let add5_lemma m1 m2 f1 f2 =
L1.add5_lemma m1 m2 f1 f2
let fadd5_lemma m1 m2 f1 f2 =
let r = add5 f1 f2 in
add5_lemma m1 m2 f1 f2;
assert (as_nat5 r == as_nat5 f1 + as_nat5 f2);
Math.Lemmas.modulo_distributivity (as_nat5 f1) (as_nat5 f2) S.prime
let mul15_lemma m1 m2 f c =
L1.mul15_lemma m1 m2 f c
let fmul15_lemma m1 m2 f c =
let r = mul15 f c in
mul15_lemma m1 m2 f c;
assert (as_nat5 r == v c * as_nat5 f);
Math.Lemmas.lemma_mod_mul_distr_r (v c) (as_nat5 f) S.prime
#push-options "--ifuel 1"
let is_felem_zero_vartime5_lemma f = ()
let is_felem_ge_prime_vartime5_lemma f =
let p =
(u64 0xffffefffffc2f,
u64 0xfffffffffffff,
u64 0xfffffffffffff,
u64 0xfffffffffffff,
u64 0xffffffffffff) in
assert_norm (S.prime = as_nat5 p);
assert_norm (0xffffefffffc2f <= max52);
assert_norm (0xfffffffffffff = max52);
assert_norm (0xffffffffffff = max48);
assert (felem_fits5 p (1,1,1,1,1));
//LD.lemma_as_nat_decompose f;
//LD.lemma_as_nat_decompose p;
LD.lemma_as_nat_bound f;
LD.lemma_as_nat_bound p
let is_felem_lt_prime_minus_order_vartime5_lemma f =
assert_norm (S.prime - S.q =
0xda1722fc9baee + 0x1950b75fc4402 * pow52 + 0x1455123 * pow104)
let is_felem_eq_vartime5_lemma f1 f2 =
if as_nat5 f1 = as_nat5 f2 then LD.as_nat_inj f1 f2
#pop-options
let normalize_weak5_lemma m f =
let r = normalize_weak5 f in
let (t0,t1,t2,t3,t4) = f in
L2.normalize_weak5_lemma m f;
assert (as_nat5 r == as_nat5 f - v t4 / pow2 48 * S.prime);
Math.Lemmas.lemma_mod_sub (as_nat5 f) S.prime (v t4 / pow2 48) | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.K256.MathLemmas.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas3.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas2.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas1.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.Lemmas.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.fst.checked",
"Hacl.Spec.K256.Field52.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.K256.Field52.Lemmas.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas3",
"short_module": "L3"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas2",
"short_module": "L2"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas1",
"short_module": "L1"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Definitions.Lemmas",
"short_module": "LD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.MathLemmas",
"short_module": "ML"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | m: Hacl.Spec.K256.Field52.Definitions.scale64_5 -> f: Hacl.Spec.K256.Field52.Definitions.felem5
-> FStar.Pervasives.Lemma
(requires
(let _ = m in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ m0 m1 m2 m3 _ = _ in
m0 + 1 <= 4096 /\ m1 + 1 <= 4096 /\ m2 + 1 <= 4096 /\ m3 + 1 <= 4096 /\
Hacl.Spec.K256.Field52.Definitions.felem_fits5 f m)
<:
Type0))
(ensures
(let r = Hacl.Spec.K256.Field52.normalize5 f in
Hacl.Spec.K256.Field52.Definitions.as_nat5 r ==
Hacl.Spec.K256.Field52.Definitions.as_nat5 f % Spec.K256.PointOps.prime /\
Hacl.Spec.K256.Field52.Definitions.felem_fits5 r (1, 1, 1, 1, 1))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.K256.Field52.Definitions.scale64_5",
"Hacl.Spec.K256.Field52.Definitions.felem5",
"Hacl.Spec.K256.Field52.Lemmas2.normalize5_lemma",
"Prims.unit"
] | [] | true | false | true | false | false | let normalize5_lemma m f =
| L2.normalize5_lemma m f | false |
RecordWithRefs.fst | RecordWithRefs.u8_pair_pred | val u8_pair_pred (p: u8_pair) (v: u8_pair_repr) : vprop | val u8_pair_pred (p: u8_pair) (v: u8_pair_repr) : vprop | let u8_pair_pred (p:u8_pair) (v:u8_pair_repr) : vprop =
R.pts_to p.a (fst v) **
R.pts_to p.b (snd v) | {
"file_name": "share/steel/examples/pulse/bug-reports/RecordWithRefs.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 24,
"end_line": 37,
"start_col": 0,
"start_line": 35
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module RecordWithRefs
open Pulse.Lib.Pervasives
module U8 = FStar.UInt8
module R = Pulse.Lib.Reference
noeq
type u8_pair = {
a: ref U8.t;
b: ref U8.t
}
let u8_pair_repr = (U8.t & U8.t)
let fst (p:u8_pair_repr) : U8.t =
let (x, _) = p in x
let snd (p:u8_pair_repr) : U8.t =
let (_, x) = p in x | {
"checked_file": "/",
"dependencies": [
"Pulse.Lib.Reference.fsti.checked",
"Pulse.Lib.Pervasives.fst.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "RecordWithRefs.fst"
} | [
{
"abbrev": true,
"full_module": "Pulse.Lib.Reference",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p: RecordWithRefs.u8_pair -> v: RecordWithRefs.u8_pair_repr -> Pulse.Lib.Core.vprop | Prims.Tot | [
"total"
] | [] | [
"RecordWithRefs.u8_pair",
"RecordWithRefs.u8_pair_repr",
"Pulse.Lib.Core.op_Star_Star",
"Pulse.Lib.Reference.pts_to",
"FStar.UInt8.t",
"RecordWithRefs.__proj__Mku8_pair__item__a",
"PulseCore.FractionalPermission.full_perm",
"RecordWithRefs.fst",
"RecordWithRefs.__proj__Mku8_pair__item__b",
"RecordWithRefs.snd",
"Pulse.Lib.Core.vprop"
] | [] | false | false | false | true | false | let u8_pair_pred (p: u8_pair) (v: u8_pair_repr) : vprop =
| R.pts_to p.a (fst v) ** R.pts_to p.b (snd v) | false |
RecordWithRefs.fst | RecordWithRefs.snd | val snd (p: u8_pair_repr) : U8.t | val snd (p: u8_pair_repr) : U8.t | let snd (p:u8_pair_repr) : U8.t =
let (_, x) = p in x | {
"file_name": "share/steel/examples/pulse/bug-reports/RecordWithRefs.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 21,
"end_line": 33,
"start_col": 0,
"start_line": 32
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module RecordWithRefs
open Pulse.Lib.Pervasives
module U8 = FStar.UInt8
module R = Pulse.Lib.Reference
noeq
type u8_pair = {
a: ref U8.t;
b: ref U8.t
}
let u8_pair_repr = (U8.t & U8.t)
let fst (p:u8_pair_repr) : U8.t = | {
"checked_file": "/",
"dependencies": [
"Pulse.Lib.Reference.fsti.checked",
"Pulse.Lib.Pervasives.fst.checked",
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "RecordWithRefs.fst"
} | [
{
"abbrev": true,
"full_module": "Pulse.Lib.Reference",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p: RecordWithRefs.u8_pair_repr -> FStar.UInt8.t | Prims.Tot | [
"total"
] | [] | [
"RecordWithRefs.u8_pair_repr",
"FStar.UInt8.t"
] | [] | false | false | false | true | false | let snd (p: u8_pair_repr) : U8.t =
| let _, x = p in
x | false |
Vale.Test.X64.Vale_memcpy.fsti | Vale.Test.X64.Vale_memcpy.va_ens_Memcpy | val va_ens_Memcpy
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(dst src: buffer64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop | val va_ens_Memcpy
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(dst src: buffer64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop | let va_ens_Memcpy (va_b0:va_code) (va_s0:va_state) (win:bool) (dst:buffer64) (src:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Memcpy va_b0 va_s0 win dst src /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok
va_sM /\ Vale.X64.Memory.buffer_as_seq #Vale.X64.Memory.vuint64 (va_get_mem va_sM) dst ==
Vale.X64.Memory.buffer_as_seq #Vale.X64.Memory.vuint64 (va_get_mem va_sM) src /\
Vale.X64.Decls.modifies_mem (Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 dst)
(va_get_mem va_s0) (va_get_mem va_sM) /\ va_state_eq va_sM (va_update_mem_heaplet 1 va_sM
(va_update_mem_layout va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))) | {
"file_name": "obj/Vale.Test.X64.Vale_memcpy.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 86,
"end_line": 37,
"start_col": 0,
"start_line": 29
} | module Vale.Test.X64.Vale_memcpy
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
#set-options "--z3rlimit 20"
//-- Memcpy
val va_code_Memcpy : win:bool -> Tot va_code
val va_codegen_success_Memcpy : win:bool -> Tot va_pbool
let va_req_Memcpy (va_b0:va_code) (va_s0:va_state) (win:bool) (dst:buffer64) (src:buffer64) : prop =
(va_require_total va_b0 (va_code_Memcpy win) va_s0 /\ va_get_ok va_s0 /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
Vale.X64.Decls.locs_disjoint ([Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 dst;
Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 src]) /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem va_s0) (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) src 2
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (if win
then va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) dst 2 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.buffer_length #Vale.X64.Memory.vuint64 src == 2 /\ | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Test.X64.Vale_memcpy.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Test.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Test.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
win: Prims.bool ->
dst: Vale.X64.Memory.buffer64 ->
src: Vale.X64.Memory.buffer64 ->
va_sM: Vale.X64.Decls.va_state ->
va_fM: Vale.X64.Decls.va_fuel
-> Prims.prop | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Prims.bool",
"Vale.X64.Memory.buffer64",
"Vale.X64.Decls.va_fuel",
"Prims.l_and",
"Vale.Test.X64.Vale_memcpy.va_req_Memcpy",
"Vale.X64.Decls.va_ensure_total",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Vale.X64.Memory.base_typ_as_vale_type",
"Vale.X64.Memory.vuint64",
"Vale.X64.Memory.buffer_as_seq",
"Vale.X64.Decls.va_get_mem",
"Vale.X64.Decls.modifies_mem",
"Vale.X64.Decls.loc_buffer",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_mem_heaplet",
"Vale.X64.Decls.va_update_mem_layout",
"Vale.X64.Decls.va_update_reg64",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRax",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_mem",
"Prims.prop"
] | [] | false | false | false | true | true | let va_ens_Memcpy
(va_b0: va_code)
(va_s0: va_state)
(win: bool)
(dst src: buffer64)
(va_sM: va_state)
(va_fM: va_fuel)
: prop =
| (va_req_Memcpy va_b0 va_s0 win dst src /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.X64.Memory.buffer_as_seq #Vale.X64.Memory.vuint64 (va_get_mem va_sM) dst ==
Vale.X64.Memory.buffer_as_seq #Vale.X64.Memory.vuint64 (va_get_mem va_sM) src /\
Vale.X64.Decls.modifies_mem (Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 dst)
(va_get_mem va_s0)
(va_get_mem va_sM) /\
va_state_eq va_sM
(va_update_mem_heaplet 1
va_sM
(va_update_mem_layout va_sM
(va_update_reg64 rR9
va_sM
(va_update_reg64 rRcx
va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))
)) | false |
Hacl.Spec.K256.Field52.Lemmas.fst | Hacl.Spec.K256.Field52.Lemmas.add5_lemma | val add5_lemma: m1:scale64_5 -> m2:scale64_5 -> f1:felem5 -> f2:felem5 -> Lemma
(requires felem_fits5 f1 m1 /\ felem_fits5 f2 m2 /\ m1 +* m2 <=* (4096,4096,4096,4096,65536))
(ensures (let r = add5 f1 f2 in
as_nat5 r == as_nat5 f1 + as_nat5 f2 /\ felem_fits5 r (m1 +* m2))) | val add5_lemma: m1:scale64_5 -> m2:scale64_5 -> f1:felem5 -> f2:felem5 -> Lemma
(requires felem_fits5 f1 m1 /\ felem_fits5 f2 m2 /\ m1 +* m2 <=* (4096,4096,4096,4096,65536))
(ensures (let r = add5 f1 f2 in
as_nat5 r == as_nat5 f1 + as_nat5 f2 /\ felem_fits5 r (m1 +* m2))) | let add5_lemma m1 m2 f1 f2 =
L1.add5_lemma m1 m2 f1 f2 | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 27,
"end_line": 28,
"start_col": 0,
"start_line": 27
} | module Hacl.Spec.K256.Field52.Lemmas
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
include Hacl.Spec.K256.Field52.Definitions
include Hacl.Spec.K256.Field52
module ML = Hacl.Spec.K256.MathLemmas
module LD = Hacl.Spec.K256.Field52.Definitions.Lemmas
module L1 = Hacl.Spec.K256.Field52.Lemmas1
module L2 = Hacl.Spec.K256.Field52.Lemmas2
module L3 = Hacl.Spec.K256.Field52.Lemmas3
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let load_felem5_lemma s =
L1.load_felem5_lemma s
let store_felem5_lemma f =
L1.store_felem5_lemma f | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.K256.MathLemmas.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas3.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas2.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas1.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.Lemmas.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.fst.checked",
"Hacl.Spec.K256.Field52.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.K256.Field52.Lemmas.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas3",
"short_module": "L3"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas2",
"short_module": "L2"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas1",
"short_module": "L1"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Definitions.Lemmas",
"short_module": "LD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.MathLemmas",
"short_module": "ML"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
m1: Hacl.Spec.K256.Field52.Definitions.scale64_5 ->
m2: Hacl.Spec.K256.Field52.Definitions.scale64_5 ->
f1: Hacl.Spec.K256.Field52.Definitions.felem5 ->
f2: Hacl.Spec.K256.Field52.Definitions.felem5
-> FStar.Pervasives.Lemma
(requires
Hacl.Spec.K256.Field52.Definitions.felem_fits5 f1 m1 /\
Hacl.Spec.K256.Field52.Definitions.felem_fits5 f2 m2 /\
m1 +* m2 <=* (4096, 4096, 4096, 4096, 65536))
(ensures
(let r = Hacl.Spec.K256.Field52.add5 f1 f2 in
Hacl.Spec.K256.Field52.Definitions.as_nat5 r ==
Hacl.Spec.K256.Field52.Definitions.as_nat5 f1 +
Hacl.Spec.K256.Field52.Definitions.as_nat5 f2 /\
Hacl.Spec.K256.Field52.Definitions.felem_fits5 r (m1 +* m2))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.K256.Field52.Definitions.scale64_5",
"Hacl.Spec.K256.Field52.Definitions.felem5",
"Hacl.Spec.K256.Field52.Lemmas1.add5_lemma",
"Prims.unit"
] | [] | true | false | true | false | false | let add5_lemma m1 m2 f1 f2 =
| L1.add5_lemma m1 m2 f1 f2 | false |
Vale.Test.X64.Vale_memcpy.fsti | Vale.Test.X64.Vale_memcpy.va_req_Memcpy | val va_req_Memcpy (va_b0: va_code) (va_s0: va_state) (win: bool) (dst src: buffer64) : prop | val va_req_Memcpy (va_b0: va_code) (va_s0: va_state) (win: bool) (dst src: buffer64) : prop | let va_req_Memcpy (va_b0:va_code) (va_s0:va_state) (win:bool) (dst:buffer64) (src:buffer64) : prop =
(va_require_total va_b0 (va_code_Memcpy win) va_s0 /\ va_get_ok va_s0 /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
Vale.X64.Decls.locs_disjoint ([Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 dst;
Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 src]) /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem va_s0) (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) src 2
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (if win
then va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) dst 2 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.buffer_length #Vale.X64.Memory.vuint64 src == 2 /\
Vale.X64.Decls.buffer_length #Vale.X64.Memory.vuint64 dst == 2) | {
"file_name": "obj/Vale.Test.X64.Vale_memcpy.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 67,
"end_line": 28,
"start_col": 0,
"start_line": 19
} | module Vale.Test.X64.Vale_memcpy
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
#set-options "--z3rlimit 20"
//-- Memcpy
val va_code_Memcpy : win:bool -> Tot va_code | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Test.X64.Vale_memcpy.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Test.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Test.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_b0: Vale.X64.Decls.va_code ->
va_s0: Vale.X64.Decls.va_state ->
win: Prims.bool ->
dst: Vale.X64.Memory.buffer64 ->
src: Vale.X64.Memory.buffer64
-> Prims.prop | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_code",
"Vale.X64.Decls.va_state",
"Prims.bool",
"Vale.X64.Memory.buffer64",
"Prims.l_and",
"Vale.X64.Decls.va_require_total",
"Vale.Test.X64.Vale_memcpy.va_code_Memcpy",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.Memory.is_initial_heap",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.X64.Decls.va_get_mem",
"Vale.X64.Decls.locs_disjoint",
"Prims.Cons",
"Vale.X64.Memory.loc",
"Vale.X64.Decls.loc_buffer",
"Vale.X64.Memory.vuint64",
"Prims.Nil",
"Vale.X64.Decls.validSrcAddrs64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.rRsi",
"Prims.int",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.validDstAddrs64",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRdi",
"Prims.eq2",
"Vale.X64.Decls.buffer_length",
"Prims.prop"
] | [] | false | false | false | true | true | let va_req_Memcpy (va_b0: va_code) (va_s0: va_state) (win: bool) (dst src: buffer64) : prop =
| (va_require_total va_b0 (va_code_Memcpy win) va_s0 /\ va_get_ok va_s0 /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
Vale.X64.Decls.locs_disjoint ([
Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 dst;
Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 src
]) /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0)
src
2
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
(if win then va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0)
dst
2
(va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.buffer_length #Vale.X64.Memory.vuint64 src == 2 /\
Vale.X64.Decls.buffer_length #Vale.X64.Memory.vuint64 dst == 2) | false |
Hacl.Spec.K256.Field52.Lemmas.fst | Hacl.Spec.K256.Field52.Lemmas.normalize_weak5_lemma | val normalize_weak5_lemma: m:scale64_5 -> f:felem5 -> Lemma
(requires (let (m0,m1,m2,m3,m4) = m in
m0 + 1 <= 4096 /\ m1 + 1 <= 4096 /\
m2 + 1 <= 4096 /\ m3 + 1 <= 4096 /\
felem_fits5 f m))
(ensures (let r = normalize_weak5 f in
as_nat5 r % S.prime == as_nat5 f % S.prime
/\ felem_fits5 r (1,1,1,1,2))) | val normalize_weak5_lemma: m:scale64_5 -> f:felem5 -> Lemma
(requires (let (m0,m1,m2,m3,m4) = m in
m0 + 1 <= 4096 /\ m1 + 1 <= 4096 /\
m2 + 1 <= 4096 /\ m3 + 1 <= 4096 /\
felem_fits5 f m))
(ensures (let r = normalize_weak5 f in
as_nat5 r % S.prime == as_nat5 f % S.prime
/\ felem_fits5 r (1,1,1,1,2))) | let normalize_weak5_lemma m f =
let r = normalize_weak5 f in
let (t0,t1,t2,t3,t4) = f in
L2.normalize_weak5_lemma m f;
assert (as_nat5 r == as_nat5 f - v t4 / pow2 48 * S.prime);
Math.Lemmas.lemma_mod_sub (as_nat5 f) S.prime (v t4 / pow2 48) | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 64,
"end_line": 86,
"start_col": 0,
"start_line": 81
} | module Hacl.Spec.K256.Field52.Lemmas
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
include Hacl.Spec.K256.Field52.Definitions
include Hacl.Spec.K256.Field52
module ML = Hacl.Spec.K256.MathLemmas
module LD = Hacl.Spec.K256.Field52.Definitions.Lemmas
module L1 = Hacl.Spec.K256.Field52.Lemmas1
module L2 = Hacl.Spec.K256.Field52.Lemmas2
module L3 = Hacl.Spec.K256.Field52.Lemmas3
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let load_felem5_lemma s =
L1.load_felem5_lemma s
let store_felem5_lemma f =
L1.store_felem5_lemma f
let add5_lemma m1 m2 f1 f2 =
L1.add5_lemma m1 m2 f1 f2
let fadd5_lemma m1 m2 f1 f2 =
let r = add5 f1 f2 in
add5_lemma m1 m2 f1 f2;
assert (as_nat5 r == as_nat5 f1 + as_nat5 f2);
Math.Lemmas.modulo_distributivity (as_nat5 f1) (as_nat5 f2) S.prime
let mul15_lemma m1 m2 f c =
L1.mul15_lemma m1 m2 f c
let fmul15_lemma m1 m2 f c =
let r = mul15 f c in
mul15_lemma m1 m2 f c;
assert (as_nat5 r == v c * as_nat5 f);
Math.Lemmas.lemma_mod_mul_distr_r (v c) (as_nat5 f) S.prime
#push-options "--ifuel 1"
let is_felem_zero_vartime5_lemma f = ()
let is_felem_ge_prime_vartime5_lemma f =
let p =
(u64 0xffffefffffc2f,
u64 0xfffffffffffff,
u64 0xfffffffffffff,
u64 0xfffffffffffff,
u64 0xffffffffffff) in
assert_norm (S.prime = as_nat5 p);
assert_norm (0xffffefffffc2f <= max52);
assert_norm (0xfffffffffffff = max52);
assert_norm (0xffffffffffff = max48);
assert (felem_fits5 p (1,1,1,1,1));
//LD.lemma_as_nat_decompose f;
//LD.lemma_as_nat_decompose p;
LD.lemma_as_nat_bound f;
LD.lemma_as_nat_bound p
let is_felem_lt_prime_minus_order_vartime5_lemma f =
assert_norm (S.prime - S.q =
0xda1722fc9baee + 0x1950b75fc4402 * pow52 + 0x1455123 * pow104)
let is_felem_eq_vartime5_lemma f1 f2 =
if as_nat5 f1 = as_nat5 f2 then LD.as_nat_inj f1 f2
#pop-options | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.K256.MathLemmas.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas3.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas2.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas1.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.Lemmas.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.fst.checked",
"Hacl.Spec.K256.Field52.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.K256.Field52.Lemmas.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas3",
"short_module": "L3"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas2",
"short_module": "L2"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas1",
"short_module": "L1"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Definitions.Lemmas",
"short_module": "LD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.MathLemmas",
"short_module": "ML"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | m: Hacl.Spec.K256.Field52.Definitions.scale64_5 -> f: Hacl.Spec.K256.Field52.Definitions.felem5
-> FStar.Pervasives.Lemma
(requires
(let _ = m in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ m0 m1 m2 m3 _ = _ in
m0 + 1 <= 4096 /\ m1 + 1 <= 4096 /\ m2 + 1 <= 4096 /\ m3 + 1 <= 4096 /\
Hacl.Spec.K256.Field52.Definitions.felem_fits5 f m)
<:
Type0))
(ensures
(let r = Hacl.Spec.K256.Field52.normalize_weak5 f in
Hacl.Spec.K256.Field52.Definitions.as_nat5 r % Spec.K256.PointOps.prime ==
Hacl.Spec.K256.Field52.Definitions.as_nat5 f % Spec.K256.PointOps.prime /\
Hacl.Spec.K256.Field52.Definitions.felem_fits5 r (1, 1, 1, 1, 2))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.K256.Field52.Definitions.scale64_5",
"Hacl.Spec.K256.Field52.Definitions.felem5",
"Lib.IntTypes.uint64",
"FStar.Math.Lemmas.lemma_mod_sub",
"Hacl.Spec.K256.Field52.Definitions.as_nat5",
"Spec.K256.PointOps.prime",
"Prims.op_Division",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.pow2",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.op_Subtraction",
"FStar.Mul.op_Star",
"Hacl.Spec.K256.Field52.Lemmas2.normalize_weak5_lemma",
"Hacl.Spec.K256.Field52.normalize_weak5"
] | [] | false | false | true | false | false | let normalize_weak5_lemma m f =
| let r = normalize_weak5 f in
let t0, t1, t2, t3, t4 = f in
L2.normalize_weak5_lemma m f;
assert (as_nat5 r == as_nat5 f - (v t4 / pow2 48) * S.prime);
Math.Lemmas.lemma_mod_sub (as_nat5 f) S.prime (v t4 / pow2 48) | false |
Vale.Test.X64.Vale_memcpy.fsti | Vale.Test.X64.Vale_memcpy.va_wp_Memcpy | val va_wp_Memcpy
(win: bool)
(dst src: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Memcpy
(win: bool)
(dst src: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Memcpy (win:bool) (dst:buffer64) (src:buffer64) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0)
/\ Vale.X64.Decls.locs_disjoint ([Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 dst;
Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 src]) /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem va_s0) (va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi
va_s0)) src 2 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem
va_s0) (va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0)) dst 2
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.buffer_length #Vale.X64.Memory.vuint64 src
== 2 /\ Vale.X64.Decls.buffer_length #Vale.X64.Memory.vuint64 dst == 2 /\ (forall
(va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rcx:nat64) (va_x_r9:nat64)
(va_x_memLayout:vale_heap_layout) (va_x_heap1:vale_heap) . let va_sM = va_upd_mem_heaplet 1
va_x_heap1 (va_upd_mem_layout va_x_memLayout (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rRcx
va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0))))) in va_get_ok va_sM /\
Vale.X64.Memory.buffer_as_seq #Vale.X64.Memory.vuint64 (va_get_mem va_sM) dst ==
Vale.X64.Memory.buffer_as_seq #Vale.X64.Memory.vuint64 (va_get_mem va_sM) src /\
Vale.X64.Decls.modifies_mem (Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 dst)
(va_get_mem va_s0) (va_get_mem va_sM) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.Test.X64.Vale_memcpy.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 63,
"end_line": 75,
"start_col": 0,
"start_line": 58
} | module Vale.Test.X64.Vale_memcpy
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
#set-options "--z3rlimit 20"
//-- Memcpy
val va_code_Memcpy : win:bool -> Tot va_code
val va_codegen_success_Memcpy : win:bool -> Tot va_pbool
let va_req_Memcpy (va_b0:va_code) (va_s0:va_state) (win:bool) (dst:buffer64) (src:buffer64) : prop =
(va_require_total va_b0 (va_code_Memcpy win) va_s0 /\ va_get_ok va_s0 /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
Vale.X64.Decls.locs_disjoint ([Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 dst;
Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 src]) /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem va_s0) (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) src 2
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (if win
then va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) dst 2 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.buffer_length #Vale.X64.Memory.vuint64 src == 2 /\
Vale.X64.Decls.buffer_length #Vale.X64.Memory.vuint64 dst == 2)
let va_ens_Memcpy (va_b0:va_code) (va_s0:va_state) (win:bool) (dst:buffer64) (src:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Memcpy va_b0 va_s0 win dst src /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok
va_sM /\ Vale.X64.Memory.buffer_as_seq #Vale.X64.Memory.vuint64 (va_get_mem va_sM) dst ==
Vale.X64.Memory.buffer_as_seq #Vale.X64.Memory.vuint64 (va_get_mem va_sM) src /\
Vale.X64.Decls.modifies_mem (Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 dst)
(va_get_mem va_s0) (va_get_mem va_sM) /\ va_state_eq va_sM (va_update_mem_heaplet 1 va_sM
(va_update_mem_layout va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))
val va_lemma_Memcpy : va_b0:va_code -> va_s0:va_state -> win:bool -> dst:buffer64 -> src:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Memcpy win) va_s0 /\ va_get_ok va_s0 /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
Vale.X64.Decls.locs_disjoint ([Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 dst;
Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 src]) /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem va_s0) (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) src 2
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (if win
then va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) dst 2 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.buffer_length #Vale.X64.Memory.vuint64 src == 2 /\
Vale.X64.Decls.buffer_length #Vale.X64.Memory.vuint64 dst == 2))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.X64.Memory.buffer_as_seq #Vale.X64.Memory.vuint64 (va_get_mem va_sM) dst ==
Vale.X64.Memory.buffer_as_seq #Vale.X64.Memory.vuint64 (va_get_mem va_sM) src /\
Vale.X64.Decls.modifies_mem (Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 dst)
(va_get_mem va_s0) (va_get_mem va_sM) /\ va_state_eq va_sM (va_update_mem_heaplet 1 va_sM
(va_update_mem_layout va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Test.X64.Vale_memcpy.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Test.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Test.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
win: Prims.bool ->
dst: Vale.X64.Memory.buffer64 ->
src: Vale.X64.Memory.buffer64 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.bool",
"Vale.X64.Memory.buffer64",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.Memory.is_initial_heap",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.X64.Decls.va_get_mem",
"Vale.X64.Decls.locs_disjoint",
"Prims.Cons",
"Vale.X64.Memory.loc",
"Vale.X64.Decls.loc_buffer",
"Vale.X64.Memory.vuint64",
"Prims.Nil",
"Vale.X64.Decls.validSrcAddrs64",
"Vale.X64.Decls.va_if",
"Vale.Def.Types_s.nat64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRdx",
"Prims.l_not",
"Vale.X64.Machine_s.rRsi",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.validDstAddrs64",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRdi",
"Prims.eq2",
"Prims.int",
"Vale.X64.Decls.buffer_length",
"Prims.l_Forall",
"Vale.X64.InsBasic.vale_heap",
"Vale.X64.Memory.nat64",
"Vale.Arch.HeapImpl.vale_heap_layout",
"Prims.l_imp",
"FStar.Seq.Base.seq",
"Vale.X64.Memory.base_typ_as_vale_type",
"Vale.X64.Memory.buffer_as_seq",
"Vale.X64.Decls.modifies_mem",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_mem_heaplet",
"Vale.X64.Decls.va_upd_mem_layout",
"Vale.X64.Decls.va_upd_reg64",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rRax",
"Vale.X64.Decls.va_upd_mem"
] | [] | false | false | false | true | true | let va_wp_Memcpy
(win: bool)
(dst src: buffer64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_get_ok va_s0 /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
Vale.X64.Decls.locs_disjoint ([
Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 dst;
Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 src
]) /\
Vale.X64.Decls.validSrcAddrs64 (va_get_mem va_s0)
(va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0))
src
2
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0)
(va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0))
dst
2
(va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.buffer_length #Vale.X64.Memory.vuint64 src == 2 /\
Vale.X64.Decls.buffer_length #Vale.X64.Memory.vuint64 dst == 2 /\
(forall (va_x_mem: vale_heap)
(va_x_rax: nat64)
(va_x_rcx: nat64)
(va_x_r9: nat64)
(va_x_memLayout: vale_heap_layout)
(va_x_heap1: vale_heap).
let va_sM =
va_upd_mem_heaplet 1
va_x_heap1
(va_upd_mem_layout va_x_memLayout
(va_upd_reg64 rR9
va_x_r9
(va_upd_reg64 rRcx
va_x_rcx
(va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0)))))
in
va_get_ok va_sM /\
Vale.X64.Memory.buffer_as_seq #Vale.X64.Memory.vuint64 (va_get_mem va_sM) dst ==
Vale.X64.Memory.buffer_as_seq #Vale.X64.Memory.vuint64 (va_get_mem va_sM) src /\
Vale.X64.Decls.modifies_mem (Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 dst)
(va_get_mem va_s0)
(va_get_mem va_sM) ==>
va_k va_sM (()))) | false |
Hacl.Spec.K256.Field52.Lemmas.fst | Hacl.Spec.K256.Field52.Lemmas.fadd5_lemma | val fadd5_lemma: m1:scale64_5 -> m2:scale64_5 -> f1:felem5 -> f2:felem5 -> Lemma
(requires felem_fits5 f1 m1 /\ felem_fits5 f2 m2 /\ m1 +* m2 <=* (4096,4096,4096,4096,65536))
(ensures (let r = add5 f1 f2 in
feval5 r == (feval5 f1 + feval5 f2) % S.prime /\ felem_fits5 r (m1 +* m2))) | val fadd5_lemma: m1:scale64_5 -> m2:scale64_5 -> f1:felem5 -> f2:felem5 -> Lemma
(requires felem_fits5 f1 m1 /\ felem_fits5 f2 m2 /\ m1 +* m2 <=* (4096,4096,4096,4096,65536))
(ensures (let r = add5 f1 f2 in
feval5 r == (feval5 f1 + feval5 f2) % S.prime /\ felem_fits5 r (m1 +* m2))) | let fadd5_lemma m1 m2 f1 f2 =
let r = add5 f1 f2 in
add5_lemma m1 m2 f1 f2;
assert (as_nat5 r == as_nat5 f1 + as_nat5 f2);
Math.Lemmas.modulo_distributivity (as_nat5 f1) (as_nat5 f2) S.prime | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 69,
"end_line": 35,
"start_col": 0,
"start_line": 31
} | module Hacl.Spec.K256.Field52.Lemmas
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
include Hacl.Spec.K256.Field52.Definitions
include Hacl.Spec.K256.Field52
module ML = Hacl.Spec.K256.MathLemmas
module LD = Hacl.Spec.K256.Field52.Definitions.Lemmas
module L1 = Hacl.Spec.K256.Field52.Lemmas1
module L2 = Hacl.Spec.K256.Field52.Lemmas2
module L3 = Hacl.Spec.K256.Field52.Lemmas3
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let load_felem5_lemma s =
L1.load_felem5_lemma s
let store_felem5_lemma f =
L1.store_felem5_lemma f
let add5_lemma m1 m2 f1 f2 =
L1.add5_lemma m1 m2 f1 f2 | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.K256.MathLemmas.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas3.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas2.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas1.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.Lemmas.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.fst.checked",
"Hacl.Spec.K256.Field52.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.K256.Field52.Lemmas.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas3",
"short_module": "L3"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas2",
"short_module": "L2"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas1",
"short_module": "L1"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Definitions.Lemmas",
"short_module": "LD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.MathLemmas",
"short_module": "ML"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
m1: Hacl.Spec.K256.Field52.Definitions.scale64_5 ->
m2: Hacl.Spec.K256.Field52.Definitions.scale64_5 ->
f1: Hacl.Spec.K256.Field52.Definitions.felem5 ->
f2: Hacl.Spec.K256.Field52.Definitions.felem5
-> FStar.Pervasives.Lemma
(requires
Hacl.Spec.K256.Field52.Definitions.felem_fits5 f1 m1 /\
Hacl.Spec.K256.Field52.Definitions.felem_fits5 f2 m2 /\
m1 +* m2 <=* (4096, 4096, 4096, 4096, 65536))
(ensures
(let r = Hacl.Spec.K256.Field52.add5 f1 f2 in
Hacl.Spec.K256.Field52.Definitions.feval5 r ==
(Hacl.Spec.K256.Field52.Definitions.feval5 f1 +
Hacl.Spec.K256.Field52.Definitions.feval5 f2) %
Spec.K256.PointOps.prime /\ Hacl.Spec.K256.Field52.Definitions.felem_fits5 r (m1 +* m2))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.K256.Field52.Definitions.scale64_5",
"Hacl.Spec.K256.Field52.Definitions.felem5",
"FStar.Math.Lemmas.modulo_distributivity",
"Hacl.Spec.K256.Field52.Definitions.as_nat5",
"Spec.K256.PointOps.prime",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.op_Addition",
"Hacl.Spec.K256.Field52.Lemmas.add5_lemma",
"Hacl.Spec.K256.Field52.add5"
] | [] | true | false | true | false | false | let fadd5_lemma m1 m2 f1 f2 =
| let r = add5 f1 f2 in
add5_lemma m1 m2 f1 f2;
assert (as_nat5 r == as_nat5 f1 + as_nat5 f2);
Math.Lemmas.modulo_distributivity (as_nat5 f1) (as_nat5 f2) S.prime | false |
Hacl.Spec.K256.Field52.Lemmas.fst | Hacl.Spec.K256.Field52.Lemmas.fmul5_lemma1 | val fmul5_lemma1: a:felem5 -> b:felem5 -> Lemma
(requires
felem_fits5 a (64,64,64,64,64) /\
felem_fits5 b (64,64,64,64,64))
(ensures (let res = fmul5 a b in
feval5 res == feval5 a * feval5 b % S.prime /\
felem_fits5 res (1,1,1,1,2))) | val fmul5_lemma1: a:felem5 -> b:felem5 -> Lemma
(requires
felem_fits5 a (64,64,64,64,64) /\
felem_fits5 b (64,64,64,64,64))
(ensures (let res = fmul5 a b in
feval5 res == feval5 a * feval5 b % S.prime /\
felem_fits5 res (1,1,1,1,2))) | let fmul5_lemma1 a b =
let r = fmul5 a b in
L3.fmul5_lemma a b;
assert (as_nat5 r % S.prime == as_nat5 a * as_nat5 b % S.prime);
ML.lemma_mod_mul_distr (as_nat5 a) (as_nat5 b) S.prime | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 56,
"end_line": 100,
"start_col": 0,
"start_line": 96
} | module Hacl.Spec.K256.Field52.Lemmas
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
include Hacl.Spec.K256.Field52.Definitions
include Hacl.Spec.K256.Field52
module ML = Hacl.Spec.K256.MathLemmas
module LD = Hacl.Spec.K256.Field52.Definitions.Lemmas
module L1 = Hacl.Spec.K256.Field52.Lemmas1
module L2 = Hacl.Spec.K256.Field52.Lemmas2
module L3 = Hacl.Spec.K256.Field52.Lemmas3
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let load_felem5_lemma s =
L1.load_felem5_lemma s
let store_felem5_lemma f =
L1.store_felem5_lemma f
let add5_lemma m1 m2 f1 f2 =
L1.add5_lemma m1 m2 f1 f2
let fadd5_lemma m1 m2 f1 f2 =
let r = add5 f1 f2 in
add5_lemma m1 m2 f1 f2;
assert (as_nat5 r == as_nat5 f1 + as_nat5 f2);
Math.Lemmas.modulo_distributivity (as_nat5 f1) (as_nat5 f2) S.prime
let mul15_lemma m1 m2 f c =
L1.mul15_lemma m1 m2 f c
let fmul15_lemma m1 m2 f c =
let r = mul15 f c in
mul15_lemma m1 m2 f c;
assert (as_nat5 r == v c * as_nat5 f);
Math.Lemmas.lemma_mod_mul_distr_r (v c) (as_nat5 f) S.prime
#push-options "--ifuel 1"
let is_felem_zero_vartime5_lemma f = ()
let is_felem_ge_prime_vartime5_lemma f =
let p =
(u64 0xffffefffffc2f,
u64 0xfffffffffffff,
u64 0xfffffffffffff,
u64 0xfffffffffffff,
u64 0xffffffffffff) in
assert_norm (S.prime = as_nat5 p);
assert_norm (0xffffefffffc2f <= max52);
assert_norm (0xfffffffffffff = max52);
assert_norm (0xffffffffffff = max48);
assert (felem_fits5 p (1,1,1,1,1));
//LD.lemma_as_nat_decompose f;
//LD.lemma_as_nat_decompose p;
LD.lemma_as_nat_bound f;
LD.lemma_as_nat_bound p
let is_felem_lt_prime_minus_order_vartime5_lemma f =
assert_norm (S.prime - S.q =
0xda1722fc9baee + 0x1950b75fc4402 * pow52 + 0x1455123 * pow104)
let is_felem_eq_vartime5_lemma f1 f2 =
if as_nat5 f1 = as_nat5 f2 then LD.as_nat_inj f1 f2
#pop-options
let normalize_weak5_lemma m f =
let r = normalize_weak5 f in
let (t0,t1,t2,t3,t4) = f in
L2.normalize_weak5_lemma m f;
assert (as_nat5 r == as_nat5 f - v t4 / pow2 48 * S.prime);
Math.Lemmas.lemma_mod_sub (as_nat5 f) S.prime (v t4 / pow2 48)
let normalize5_lemma m f =
L2.normalize5_lemma m f
let fmul5_lemma a b =
L3.fmul5_lemma a b | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.K256.MathLemmas.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas3.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas2.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas1.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.Lemmas.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.fst.checked",
"Hacl.Spec.K256.Field52.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.K256.Field52.Lemmas.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas3",
"short_module": "L3"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas2",
"short_module": "L2"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas1",
"short_module": "L1"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Definitions.Lemmas",
"short_module": "LD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.MathLemmas",
"short_module": "ML"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Hacl.Spec.K256.Field52.Definitions.felem5 -> b: Hacl.Spec.K256.Field52.Definitions.felem5
-> FStar.Pervasives.Lemma
(requires
Hacl.Spec.K256.Field52.Definitions.felem_fits5 a (64, 64, 64, 64, 64) /\
Hacl.Spec.K256.Field52.Definitions.felem_fits5 b (64, 64, 64, 64, 64))
(ensures
(let res = Hacl.Spec.K256.Field52.fmul5 a b in
Hacl.Spec.K256.Field52.Definitions.feval5 res ==
Hacl.Spec.K256.Field52.Definitions.feval5 a * Hacl.Spec.K256.Field52.Definitions.feval5 b %
Spec.K256.PointOps.prime /\
Hacl.Spec.K256.Field52.Definitions.felem_fits5 res (1, 1, 1, 1, 2))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.K256.Field52.Definitions.felem5",
"Hacl.Spec.K256.MathLemmas.lemma_mod_mul_distr",
"Hacl.Spec.K256.Field52.Definitions.as_nat5",
"Spec.K256.PointOps.prime",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"Hacl.Spec.K256.Field52.Lemmas3.fmul5_lemma",
"Hacl.Spec.K256.Field52.fmul5"
] | [] | true | false | true | false | false | let fmul5_lemma1 a b =
| let r = fmul5 a b in
L3.fmul5_lemma a b;
assert (as_nat5 r % S.prime == as_nat5 a * as_nat5 b % S.prime);
ML.lemma_mod_mul_distr (as_nat5 a) (as_nat5 b) S.prime | false |
Hacl.Spec.K256.Field52.Lemmas.fst | Hacl.Spec.K256.Field52.Lemmas.mul15_lemma | val mul15_lemma: m1:scale64_5 -> m2:nat -> f:felem5 -> c:uint64 -> Lemma
(requires felem_fits5 f m1 /\ v c <= m2 /\ m1 ** mk_nat5 m2 <=* (4096,4096,4096,4096,65536))
(ensures (let r = mul15 f c in
as_nat5 r == v c * as_nat5 f /\ felem_fits5 r (m1 ** mk_nat5 m2))) | val mul15_lemma: m1:scale64_5 -> m2:nat -> f:felem5 -> c:uint64 -> Lemma
(requires felem_fits5 f m1 /\ v c <= m2 /\ m1 ** mk_nat5 m2 <=* (4096,4096,4096,4096,65536))
(ensures (let r = mul15 f c in
as_nat5 r == v c * as_nat5 f /\ felem_fits5 r (m1 ** mk_nat5 m2))) | let mul15_lemma m1 m2 f c =
L1.mul15_lemma m1 m2 f c | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 26,
"end_line": 39,
"start_col": 0,
"start_line": 38
} | module Hacl.Spec.K256.Field52.Lemmas
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
include Hacl.Spec.K256.Field52.Definitions
include Hacl.Spec.K256.Field52
module ML = Hacl.Spec.K256.MathLemmas
module LD = Hacl.Spec.K256.Field52.Definitions.Lemmas
module L1 = Hacl.Spec.K256.Field52.Lemmas1
module L2 = Hacl.Spec.K256.Field52.Lemmas2
module L3 = Hacl.Spec.K256.Field52.Lemmas3
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let load_felem5_lemma s =
L1.load_felem5_lemma s
let store_felem5_lemma f =
L1.store_felem5_lemma f
let add5_lemma m1 m2 f1 f2 =
L1.add5_lemma m1 m2 f1 f2
let fadd5_lemma m1 m2 f1 f2 =
let r = add5 f1 f2 in
add5_lemma m1 m2 f1 f2;
assert (as_nat5 r == as_nat5 f1 + as_nat5 f2);
Math.Lemmas.modulo_distributivity (as_nat5 f1) (as_nat5 f2) S.prime | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.K256.MathLemmas.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas3.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas2.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas1.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.Lemmas.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.fst.checked",
"Hacl.Spec.K256.Field52.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.K256.Field52.Lemmas.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas3",
"short_module": "L3"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas2",
"short_module": "L2"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas1",
"short_module": "L1"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Definitions.Lemmas",
"short_module": "LD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.MathLemmas",
"short_module": "ML"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
m1: Hacl.Spec.K256.Field52.Definitions.scale64_5 ->
m2: Prims.nat ->
f: Hacl.Spec.K256.Field52.Definitions.felem5 ->
c: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(requires
Hacl.Spec.K256.Field52.Definitions.felem_fits5 f m1 /\ Lib.IntTypes.v c <= m2 /\
m1 ** Hacl.Spec.K256.Field52.Definitions.mk_nat5 m2 <=* (4096, 4096, 4096, 4096, 65536))
(ensures
(let r = Hacl.Spec.K256.Field52.mul15 f c in
Hacl.Spec.K256.Field52.Definitions.as_nat5 r ==
Lib.IntTypes.v c * Hacl.Spec.K256.Field52.Definitions.as_nat5 f /\
Hacl.Spec.K256.Field52.Definitions.felem_fits5 r
(m1 ** Hacl.Spec.K256.Field52.Definitions.mk_nat5 m2))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.K256.Field52.Definitions.scale64_5",
"Prims.nat",
"Hacl.Spec.K256.Field52.Definitions.felem5",
"Lib.IntTypes.uint64",
"Hacl.Spec.K256.Field52.Lemmas1.mul15_lemma",
"Prims.unit"
] | [] | true | false | true | false | false | let mul15_lemma m1 m2 f c =
| L1.mul15_lemma m1 m2 f c | false |
Hacl.Spec.K256.Field52.Lemmas.fst | Hacl.Spec.K256.Field52.Lemmas.fmul15_lemma | val fmul15_lemma: m1:scale64_5 -> m2:nat -> f:felem5 -> c:uint64 -> Lemma
(requires felem_fits5 f m1 /\ v c <= m2 /\ m1 ** mk_nat5 m2 <=* (4096,4096,4096,4096,65536))
(ensures (let r = mul15 f c in
feval5 r == v c * feval5 f % S.prime /\ felem_fits5 r (m1 ** mk_nat5 m2))) | val fmul15_lemma: m1:scale64_5 -> m2:nat -> f:felem5 -> c:uint64 -> Lemma
(requires felem_fits5 f m1 /\ v c <= m2 /\ m1 ** mk_nat5 m2 <=* (4096,4096,4096,4096,65536))
(ensures (let r = mul15 f c in
feval5 r == v c * feval5 f % S.prime /\ felem_fits5 r (m1 ** mk_nat5 m2))) | let fmul15_lemma m1 m2 f c =
let r = mul15 f c in
mul15_lemma m1 m2 f c;
assert (as_nat5 r == v c * as_nat5 f);
Math.Lemmas.lemma_mod_mul_distr_r (v c) (as_nat5 f) S.prime | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 61,
"end_line": 46,
"start_col": 0,
"start_line": 42
} | module Hacl.Spec.K256.Field52.Lemmas
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
include Hacl.Spec.K256.Field52.Definitions
include Hacl.Spec.K256.Field52
module ML = Hacl.Spec.K256.MathLemmas
module LD = Hacl.Spec.K256.Field52.Definitions.Lemmas
module L1 = Hacl.Spec.K256.Field52.Lemmas1
module L2 = Hacl.Spec.K256.Field52.Lemmas2
module L3 = Hacl.Spec.K256.Field52.Lemmas3
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let load_felem5_lemma s =
L1.load_felem5_lemma s
let store_felem5_lemma f =
L1.store_felem5_lemma f
let add5_lemma m1 m2 f1 f2 =
L1.add5_lemma m1 m2 f1 f2
let fadd5_lemma m1 m2 f1 f2 =
let r = add5 f1 f2 in
add5_lemma m1 m2 f1 f2;
assert (as_nat5 r == as_nat5 f1 + as_nat5 f2);
Math.Lemmas.modulo_distributivity (as_nat5 f1) (as_nat5 f2) S.prime
let mul15_lemma m1 m2 f c =
L1.mul15_lemma m1 m2 f c | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.K256.MathLemmas.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas3.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas2.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas1.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.Lemmas.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.fst.checked",
"Hacl.Spec.K256.Field52.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.K256.Field52.Lemmas.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas3",
"short_module": "L3"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas2",
"short_module": "L2"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas1",
"short_module": "L1"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Definitions.Lemmas",
"short_module": "LD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.MathLemmas",
"short_module": "ML"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
m1: Hacl.Spec.K256.Field52.Definitions.scale64_5 ->
m2: Prims.nat ->
f: Hacl.Spec.K256.Field52.Definitions.felem5 ->
c: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(requires
Hacl.Spec.K256.Field52.Definitions.felem_fits5 f m1 /\ Lib.IntTypes.v c <= m2 /\
m1 ** Hacl.Spec.K256.Field52.Definitions.mk_nat5 m2 <=* (4096, 4096, 4096, 4096, 65536))
(ensures
(let r = Hacl.Spec.K256.Field52.mul15 f c in
Hacl.Spec.K256.Field52.Definitions.feval5 r ==
Lib.IntTypes.v c * Hacl.Spec.K256.Field52.Definitions.feval5 f % Spec.K256.PointOps.prime /\
Hacl.Spec.K256.Field52.Definitions.felem_fits5 r
(m1 ** Hacl.Spec.K256.Field52.Definitions.mk_nat5 m2))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.K256.Field52.Definitions.scale64_5",
"Prims.nat",
"Hacl.Spec.K256.Field52.Definitions.felem5",
"Lib.IntTypes.uint64",
"FStar.Math.Lemmas.lemma_mod_mul_distr_r",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Hacl.Spec.K256.Field52.Definitions.as_nat5",
"Spec.K256.PointOps.prime",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"FStar.Mul.op_Star",
"Hacl.Spec.K256.Field52.Lemmas.mul15_lemma",
"Hacl.Spec.K256.Field52.mul15"
] | [] | true | false | true | false | false | let fmul15_lemma m1 m2 f c =
| let r = mul15 f c in
mul15_lemma m1 m2 f c;
assert (as_nat5 r == v c * as_nat5 f);
Math.Lemmas.lemma_mod_mul_distr_r (v c) (as_nat5 f) S.prime | false |
Hacl.Spec.K256.Field52.Lemmas.fst | Hacl.Spec.K256.Field52.Lemmas.fmul5_lemma | val fmul5_lemma: a:felem5 -> b:felem5 -> Lemma
(requires
felem_fits5 a (64,64,64,64,64) /\
felem_fits5 b (64,64,64,64,64))
(ensures (let res = fmul5 a b in
as_nat5 res % S.prime == as_nat5 a * as_nat5 b % S.prime /\
felem_fits5 res (1,1,1,1,2))) | val fmul5_lemma: a:felem5 -> b:felem5 -> Lemma
(requires
felem_fits5 a (64,64,64,64,64) /\
felem_fits5 b (64,64,64,64,64))
(ensures (let res = fmul5 a b in
as_nat5 res % S.prime == as_nat5 a * as_nat5 b % S.prime /\
felem_fits5 res (1,1,1,1,2))) | let fmul5_lemma a b =
L3.fmul5_lemma a b | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 20,
"end_line": 94,
"start_col": 0,
"start_line": 93
} | module Hacl.Spec.K256.Field52.Lemmas
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
include Hacl.Spec.K256.Field52.Definitions
include Hacl.Spec.K256.Field52
module ML = Hacl.Spec.K256.MathLemmas
module LD = Hacl.Spec.K256.Field52.Definitions.Lemmas
module L1 = Hacl.Spec.K256.Field52.Lemmas1
module L2 = Hacl.Spec.K256.Field52.Lemmas2
module L3 = Hacl.Spec.K256.Field52.Lemmas3
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let load_felem5_lemma s =
L1.load_felem5_lemma s
let store_felem5_lemma f =
L1.store_felem5_lemma f
let add5_lemma m1 m2 f1 f2 =
L1.add5_lemma m1 m2 f1 f2
let fadd5_lemma m1 m2 f1 f2 =
let r = add5 f1 f2 in
add5_lemma m1 m2 f1 f2;
assert (as_nat5 r == as_nat5 f1 + as_nat5 f2);
Math.Lemmas.modulo_distributivity (as_nat5 f1) (as_nat5 f2) S.prime
let mul15_lemma m1 m2 f c =
L1.mul15_lemma m1 m2 f c
let fmul15_lemma m1 m2 f c =
let r = mul15 f c in
mul15_lemma m1 m2 f c;
assert (as_nat5 r == v c * as_nat5 f);
Math.Lemmas.lemma_mod_mul_distr_r (v c) (as_nat5 f) S.prime
#push-options "--ifuel 1"
let is_felem_zero_vartime5_lemma f = ()
let is_felem_ge_prime_vartime5_lemma f =
let p =
(u64 0xffffefffffc2f,
u64 0xfffffffffffff,
u64 0xfffffffffffff,
u64 0xfffffffffffff,
u64 0xffffffffffff) in
assert_norm (S.prime = as_nat5 p);
assert_norm (0xffffefffffc2f <= max52);
assert_norm (0xfffffffffffff = max52);
assert_norm (0xffffffffffff = max48);
assert (felem_fits5 p (1,1,1,1,1));
//LD.lemma_as_nat_decompose f;
//LD.lemma_as_nat_decompose p;
LD.lemma_as_nat_bound f;
LD.lemma_as_nat_bound p
let is_felem_lt_prime_minus_order_vartime5_lemma f =
assert_norm (S.prime - S.q =
0xda1722fc9baee + 0x1950b75fc4402 * pow52 + 0x1455123 * pow104)
let is_felem_eq_vartime5_lemma f1 f2 =
if as_nat5 f1 = as_nat5 f2 then LD.as_nat_inj f1 f2
#pop-options
let normalize_weak5_lemma m f =
let r = normalize_weak5 f in
let (t0,t1,t2,t3,t4) = f in
L2.normalize_weak5_lemma m f;
assert (as_nat5 r == as_nat5 f - v t4 / pow2 48 * S.prime);
Math.Lemmas.lemma_mod_sub (as_nat5 f) S.prime (v t4 / pow2 48)
let normalize5_lemma m f =
L2.normalize5_lemma m f | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.K256.MathLemmas.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas3.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas2.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas1.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.Lemmas.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.fst.checked",
"Hacl.Spec.K256.Field52.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.K256.Field52.Lemmas.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas3",
"short_module": "L3"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas2",
"short_module": "L2"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas1",
"short_module": "L1"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Definitions.Lemmas",
"short_module": "LD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.MathLemmas",
"short_module": "ML"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Hacl.Spec.K256.Field52.Definitions.felem5 -> b: Hacl.Spec.K256.Field52.Definitions.felem5
-> FStar.Pervasives.Lemma
(requires
Hacl.Spec.K256.Field52.Definitions.felem_fits5 a (64, 64, 64, 64, 64) /\
Hacl.Spec.K256.Field52.Definitions.felem_fits5 b (64, 64, 64, 64, 64))
(ensures
(let res = Hacl.Spec.K256.Field52.fmul5 a b in
Hacl.Spec.K256.Field52.Definitions.as_nat5 res % Spec.K256.PointOps.prime ==
Hacl.Spec.K256.Field52.Definitions.as_nat5 a *
Hacl.Spec.K256.Field52.Definitions.as_nat5 b %
Spec.K256.PointOps.prime /\
Hacl.Spec.K256.Field52.Definitions.felem_fits5 res (1, 1, 1, 1, 2))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.K256.Field52.Definitions.felem5",
"Hacl.Spec.K256.Field52.Lemmas3.fmul5_lemma",
"Prims.unit"
] | [] | true | false | true | false | false | let fmul5_lemma a b =
| L3.fmul5_lemma a b | false |
Hacl.Spec.K256.Field52.Lemmas.fst | Hacl.Spec.K256.Field52.Lemmas.is_felem_lt_prime_minus_order_vartime5_lemma | val is_felem_lt_prime_minus_order_vartime5_lemma: f:felem5 -> Lemma
(requires felem_fits5 f (1,1,1,1,1))
(ensures is_felem_lt_prime_minus_order_vartime5 f == (as_nat5 f < S.prime - S.q)) | val is_felem_lt_prime_minus_order_vartime5_lemma: f:felem5 -> Lemma
(requires felem_fits5 f (1,1,1,1,1))
(ensures is_felem_lt_prime_minus_order_vartime5 f == (as_nat5 f < S.prime - S.q)) | let is_felem_lt_prime_minus_order_vartime5_lemma f =
assert_norm (S.prime - S.q =
0xda1722fc9baee + 0x1950b75fc4402 * pow52 + 0x1455123 * pow104) | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 67,
"end_line": 73,
"start_col": 0,
"start_line": 71
} | module Hacl.Spec.K256.Field52.Lemmas
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
include Hacl.Spec.K256.Field52.Definitions
include Hacl.Spec.K256.Field52
module ML = Hacl.Spec.K256.MathLemmas
module LD = Hacl.Spec.K256.Field52.Definitions.Lemmas
module L1 = Hacl.Spec.K256.Field52.Lemmas1
module L2 = Hacl.Spec.K256.Field52.Lemmas2
module L3 = Hacl.Spec.K256.Field52.Lemmas3
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let load_felem5_lemma s =
L1.load_felem5_lemma s
let store_felem5_lemma f =
L1.store_felem5_lemma f
let add5_lemma m1 m2 f1 f2 =
L1.add5_lemma m1 m2 f1 f2
let fadd5_lemma m1 m2 f1 f2 =
let r = add5 f1 f2 in
add5_lemma m1 m2 f1 f2;
assert (as_nat5 r == as_nat5 f1 + as_nat5 f2);
Math.Lemmas.modulo_distributivity (as_nat5 f1) (as_nat5 f2) S.prime
let mul15_lemma m1 m2 f c =
L1.mul15_lemma m1 m2 f c
let fmul15_lemma m1 m2 f c =
let r = mul15 f c in
mul15_lemma m1 m2 f c;
assert (as_nat5 r == v c * as_nat5 f);
Math.Lemmas.lemma_mod_mul_distr_r (v c) (as_nat5 f) S.prime
#push-options "--ifuel 1"
let is_felem_zero_vartime5_lemma f = ()
let is_felem_ge_prime_vartime5_lemma f =
let p =
(u64 0xffffefffffc2f,
u64 0xfffffffffffff,
u64 0xfffffffffffff,
u64 0xfffffffffffff,
u64 0xffffffffffff) in
assert_norm (S.prime = as_nat5 p);
assert_norm (0xffffefffffc2f <= max52);
assert_norm (0xfffffffffffff = max52);
assert_norm (0xffffffffffff = max48);
assert (felem_fits5 p (1,1,1,1,1));
//LD.lemma_as_nat_decompose f;
//LD.lemma_as_nat_decompose p;
LD.lemma_as_nat_bound f;
LD.lemma_as_nat_bound p | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.K256.MathLemmas.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas3.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas2.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas1.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.Lemmas.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.fst.checked",
"Hacl.Spec.K256.Field52.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.K256.Field52.Lemmas.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas3",
"short_module": "L3"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas2",
"short_module": "L2"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas1",
"short_module": "L1"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Definitions.Lemmas",
"short_module": "LD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.MathLemmas",
"short_module": "ML"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | f: Hacl.Spec.K256.Field52.Definitions.felem5
-> FStar.Pervasives.Lemma
(requires Hacl.Spec.K256.Field52.Definitions.felem_fits5 f (1, 1, 1, 1, 1))
(ensures
Hacl.Spec.K256.Field52.is_felem_lt_prime_minus_order_vartime5 f ==
(Hacl.Spec.K256.Field52.Definitions.as_nat5 f <
Spec.K256.PointOps.prime - Spec.K256.PointOps.q)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.K256.Field52.Definitions.felem5",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Subtraction",
"Spec.K256.PointOps.prime",
"Spec.K256.PointOps.q",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Hacl.Spec.K256.Field52.Definitions.pow52",
"Hacl.Spec.K256.Field52.Definitions.pow104",
"Prims.unit"
] | [] | true | false | true | false | false | let is_felem_lt_prime_minus_order_vartime5_lemma f =
| assert_norm (S.prime - S.q = 0xda1722fc9baee + 0x1950b75fc4402 * pow52 + 0x1455123 * pow104) | false |
DependentBoolRefinement.fst | DependentBoolRefinement.elab_close_commute' | val elab_close_commute' (n: nat) (e: src_exp) (x: var)
: Lemma (ensures RT.subst_term (elab_exp e) [RT.ND x n] == elab_exp (close_exp' e x n))
(decreases e) | val elab_close_commute' (n: nat) (e: src_exp) (x: var)
: Lemma (ensures RT.subst_term (elab_exp e) [RT.ND x n] == elab_exp (close_exp' e x n))
(decreases e) | let rec elab_close_commute' (n:nat) (e:src_exp) (x:var)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.ND x n ] ==
elab_exp (close_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_close_commute' n e1 x;
elab_close_commute' n e2 x
| EIf b e1 e2 ->
elab_close_commute' n b x;
elab_close_commute' n e1 x;
elab_close_commute' n e2 x
| ELam t e ->
elab_ty_close_commute' n t x;
elab_close_commute' (n + 1) e x
and elab_ty_close_commute' (n:nat) (e:src_ty) (x:var)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.ND x n ] ==
elab_ty (close_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_close_commute' n t x;
elab_ty_close_commute' (n + 1) t' x
| TRefineBool e ->
elab_close_commute' (n + 1) e x | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 37,
"end_line": 683,
"start_col": 0,
"start_line": 650
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1
let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1
let check_sub_typing f
(sg:src_env)
(t0 t1:src_ty)
: T.Tac (sub_typing f sg t0 t1)
= if t0 = t1 then S_Refl _ t0
else T.fail "Not subtypes"
let weaken (f:fstar_top_env) (sg:src_env) (hyp:var { None? (lookup sg hyp) } ) (b:src_exp) (t0 t1:src_ty)
: T.Tac (t:src_ty &
sub_typing f ((hyp,Inr(b, EBool true))::sg) t0 t &
sub_typing f ((hyp,Inr(b, EBool false))::sg) t1 t)
= if t0 = t1
then (| t0, S_Refl _ t0, S_Refl _ t1 |)
else T.fail "weaken is very dumb"
let ok (sg:src_env) (e:src_exp) = (forall x. x `Set.mem` freevars e ==> Some? (lookup sg x))
let ok_ty (sg:src_env) (e:src_ty) = (forall x. x `Set.mem` freevars_ty e ==> Some? (lookup sg x))
let rec check_ok_ty (t:src_ty) (sg:src_env)
: b:bool { b <==> (ok_ty sg t) }
= match t with
| TBool -> true
| TArrow t1 t2 ->
check_ok_ty t1 sg &&
check_ok_ty t2 sg
| TRefineBool e ->
check_ok e sg
and check_ok (e:src_exp) (sg:src_env)
: b:bool { b <==> ok sg e }
= match e with
| EBVar _ -> true
| EVar x -> Some? (lookup sg x)
| EBool _ -> true
| EIf b e1 e2 -> check_ok b sg && check_ok e1 sg && check_ok e2 sg
| ELam t e -> check_ok_ty t sg && check_ok e sg
| EApp e1 e2 -> check_ok e1 sg && check_ok e2 sg
#push-options "--fuel 2 --ifuel 2 --z3rlimit_factor 6 --query_stats"
let rec check (f:fstar_top_env)
(sg:src_env)
(e:src_exp { ok sg e })
: T.Tac (t:src_ty &
src_typing f sg e t)
= match e with
| EBVar _ ->
T.fail "Not locally nameless"
| EBool b ->
(| TBool, T_Bool _ b |)
| EVar n ->
begin
match lookup_ty sg n with
| None -> T.fail "Ill-typed"
| Some t ->
let d = T_Var sg n in
(| t, d |)
end
| ELam t body ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars body (EVar x) 0;
let (| tbody, dbody |) = check f ((x, Inl t)::sg) (open_exp body x) in
let dd : src_typing f sg e (TArrow t (close_ty tbody x)) =
T_Lam sg t body tbody x t_ok dbody in
(| TArrow t (close_ty tbody x), dd |)
| EApp e1 e2 ->
let (| t1, d1 |) = check f sg e1 in
let (| t2, d2 |) = check f sg e2 in
begin
match t1 with
| TArrow t_arg t_res ->
let st_ok = check_sub_typing f sg t2 t_arg in
(| open_ty_with t_res e2, T_App _ _ _ t_arg t_res _ d1 d2 st_ok |)
| _ ->
T.fail "Expected a function"
end
| EIf b e1 e2 ->
let (| tb, ok_b |) = check f sg b in
let hyp = fresh sg in
fresh_is_fresh sg;
if tb = TBool
then (
let (| t1, ok_1 |) = check f ((hyp, Inr(b, EBool true))::sg) e1 in
let (| t2, ok_2 |) = check f ((hyp, Inr(b, EBool false))::sg) e2 in
let (| t, w1, w2 |) = weaken f sg hyp b t1 t2 in
if not (check_ok_ty t sg)
then T.fail "Free variable escapes scope"
else (
let t_ok = check_ty f sg t in
(| t, T_If _ _ _ _ _ _ _ hyp ok_b ok_1 ok_2 w1 w2 t_ok |)
)
)
else T.fail "Branching on a non-boolean"
and check_ty (f:fstar_top_env)
(sg:src_env)
(t:src_ty { ok_ty sg t })
: T.Tac (src_ty_ok f sg t)
= match t with
| TBool -> OK_TBool _
| TArrow t t' ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_ty_freevars t' (EVar x) 0;
let t'_ok = check_ty f ((x, Inl t)::sg) (open_ty t' x) in
OK_TArrow _ _ _ x t_ok t'_ok
| TRefineBool e ->
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars e (EVar x) 0;
let (| te, de |) = check f ((x, Inl TBool)::sg) (open_exp e x) in
match te with
| TBool -> OK_TRefine sg e x de
| _ -> T.fail "Ill-typed refinement"
#pop-options
let rec extend_env_l_lookup_bvar (g:R.env) (sg:src_env) (x:var)
: Lemma
(requires (forall x. RT.lookup_bvar g x == None))
(ensures (
match lookup sg x with
| Some b -> RT.lookup_bvar (extend_env_l g sg) x == Some (elab_binding b)
| None -> RT.lookup_bvar (extend_env_l g sg) x == None))
(decreases sg)
[SMTPat (RT.lookup_bvar (extend_env_l g sg) x)]
= match sg with
| [] -> ()
| hd :: tl -> extend_env_l_lookup_bvar g tl x
#push-options "--query_stats --fuel 8 --ifuel 2 --z3rlimit_factor 2"
let rec elab_open_commute' (n:nat) (e:src_exp) (x:src_exp)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.DT n (elab_exp x) ] ==
elab_exp (open_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| EIf b e1 e2 ->
elab_open_commute' n b x;
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| ELam t e ->
elab_ty_open_commute' n t x;
elab_open_commute' (n + 1) e x
and elab_ty_open_commute' (n:nat) (e:src_ty) (x:src_exp)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.DT n (elab_exp x) ] ==
elab_ty (open_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_open_commute' n t x;
elab_ty_open_commute' (n + 1) t' x
| TRefineBool e ->
elab_open_commute' (n + 1) e x
#pop-options
let elab_open_commute (e:src_exp) (x:var)
: Lemma (RT.open_term (elab_exp e) x == elab_exp (open_exp e x))
[SMTPat (RT.open_term (elab_exp e) x)]
= elab_open_commute' 0 e (EVar x);
RT.open_term_spec (elab_exp e) x
let b2t_typing (g:fstar_env) (t:R.term) (dt:RT.tot_typing g t RT.bool_ty)
: RT.tot_typing g (r_b2t t) (RT.tm_type RT.u_zero)
= let b2t_typing : RT.tot_typing g _ b2t_ty = RT.T_FVar g b2t_fv in
let app_ty : _ = RT.T_App _ _ _ _ (RT.tm_type RT.u_zero) _ b2t_typing dt in
RT.open_with_spec (RT.tm_type RT.u_zero) t;
app_ty
let rec extend_env_l_lookup_fvar (g:R.env) (sg:src_env) (fv:R.fv)
: Lemma
(ensures
RT.lookup_fvar (extend_env_l g sg) fv ==
RT.lookup_fvar g fv)
[SMTPat (RT.lookup_fvar (extend_env_l g sg) fv)]
= match sg with
| [] -> ()
| hd::tl -> extend_env_l_lookup_fvar g tl fv
#push-options "--query_stats --fuel 2 --ifuel 2 --z3rlimit_factor 2"
let subtyping_soundness #f (#sg:src_env) (#t0 #t1:src_ty) (ds:sub_typing f sg t0 t1)
: GTot (RT.sub_typing (extend_env_l f sg) (elab_ty t0) (elab_ty t1))
= match ds with
| S_Refl _ _ -> RT.Rel_equiv _ _ _ _ (RT.Rel_refl _ _ _)
| S_ELab _ _ _ d -> d | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 8,
"initial_ifuel": 2,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | n: Prims.nat -> e: DependentBoolRefinement.src_exp -> x: DependentBoolRefinement.var
-> FStar.Pervasives.Lemma
(ensures
FStar.Reflection.Typing.subst_term (DependentBoolRefinement.elab_exp e)
[FStar.Reflection.Typing.ND x n] ==
DependentBoolRefinement.elab_exp (DependentBoolRefinement.close_exp' e x n)) (decreases e) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [
"elab_close_commute'",
"elab_ty_close_commute'"
] | [
"Prims.nat",
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.var",
"Prims.bool",
"DependentBoolRefinement.index",
"DependentBoolRefinement.elab_close_commute'",
"Prims.unit",
"DependentBoolRefinement.src_ty",
"Prims.op_Addition",
"DependentBoolRefinement.elab_ty_close_commute'",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Stubs.Reflection.Types.term",
"FStar.Reflection.Typing.subst_term",
"DependentBoolRefinement.elab_exp",
"Prims.Cons",
"FStar.Reflection.Typing.subst_elt",
"FStar.Reflection.Typing.ND",
"Prims.Nil",
"DependentBoolRefinement.close_exp'",
"FStar.Pervasives.pattern"
] | [
"mutual recursion"
] | false | false | true | false | false | let rec elab_close_commute' (n: nat) (e: src_exp) (x: var)
: Lemma (ensures RT.subst_term (elab_exp e) [RT.ND x n] == elab_exp (close_exp' e x n))
(decreases e) =
| match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_close_commute' n e1 x;
elab_close_commute' n e2 x
| EIf b e1 e2 ->
elab_close_commute' n b x;
elab_close_commute' n e1 x;
elab_close_commute' n e2 x
| ELam t e ->
elab_ty_close_commute' n t x;
elab_close_commute' (n + 1) e x | false |
Hacl.Spec.K256.Field52.Lemmas.fst | Hacl.Spec.K256.Field52.Lemmas.fsqr5_lemma1 | val fsqr5_lemma1: a:felem5 -> Lemma
(requires
felem_fits5 a (64,64,64,64,64))
(ensures (let res = fsqr5 a in
feval5 res == feval5 a * feval5 a % S.prime /\
felem_fits5 res (1,1,1,1,2))) | val fsqr5_lemma1: a:felem5 -> Lemma
(requires
felem_fits5 a (64,64,64,64,64))
(ensures (let res = fsqr5 a in
feval5 res == feval5 a * feval5 a % S.prime /\
felem_fits5 res (1,1,1,1,2))) | let fsqr5_lemma1 a =
let r = fsqr5 a in
L3.fsqr5_lemma a;
assert (as_nat5 r % S.prime == as_nat5 a * as_nat5 a % S.prime);
ML.lemma_mod_mul_distr (as_nat5 a) (as_nat5 a) S.prime | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 56,
"end_line": 110,
"start_col": 0,
"start_line": 106
} | module Hacl.Spec.K256.Field52.Lemmas
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
include Hacl.Spec.K256.Field52.Definitions
include Hacl.Spec.K256.Field52
module ML = Hacl.Spec.K256.MathLemmas
module LD = Hacl.Spec.K256.Field52.Definitions.Lemmas
module L1 = Hacl.Spec.K256.Field52.Lemmas1
module L2 = Hacl.Spec.K256.Field52.Lemmas2
module L3 = Hacl.Spec.K256.Field52.Lemmas3
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let load_felem5_lemma s =
L1.load_felem5_lemma s
let store_felem5_lemma f =
L1.store_felem5_lemma f
let add5_lemma m1 m2 f1 f2 =
L1.add5_lemma m1 m2 f1 f2
let fadd5_lemma m1 m2 f1 f2 =
let r = add5 f1 f2 in
add5_lemma m1 m2 f1 f2;
assert (as_nat5 r == as_nat5 f1 + as_nat5 f2);
Math.Lemmas.modulo_distributivity (as_nat5 f1) (as_nat5 f2) S.prime
let mul15_lemma m1 m2 f c =
L1.mul15_lemma m1 m2 f c
let fmul15_lemma m1 m2 f c =
let r = mul15 f c in
mul15_lemma m1 m2 f c;
assert (as_nat5 r == v c * as_nat5 f);
Math.Lemmas.lemma_mod_mul_distr_r (v c) (as_nat5 f) S.prime
#push-options "--ifuel 1"
let is_felem_zero_vartime5_lemma f = ()
let is_felem_ge_prime_vartime5_lemma f =
let p =
(u64 0xffffefffffc2f,
u64 0xfffffffffffff,
u64 0xfffffffffffff,
u64 0xfffffffffffff,
u64 0xffffffffffff) in
assert_norm (S.prime = as_nat5 p);
assert_norm (0xffffefffffc2f <= max52);
assert_norm (0xfffffffffffff = max52);
assert_norm (0xffffffffffff = max48);
assert (felem_fits5 p (1,1,1,1,1));
//LD.lemma_as_nat_decompose f;
//LD.lemma_as_nat_decompose p;
LD.lemma_as_nat_bound f;
LD.lemma_as_nat_bound p
let is_felem_lt_prime_minus_order_vartime5_lemma f =
assert_norm (S.prime - S.q =
0xda1722fc9baee + 0x1950b75fc4402 * pow52 + 0x1455123 * pow104)
let is_felem_eq_vartime5_lemma f1 f2 =
if as_nat5 f1 = as_nat5 f2 then LD.as_nat_inj f1 f2
#pop-options
let normalize_weak5_lemma m f =
let r = normalize_weak5 f in
let (t0,t1,t2,t3,t4) = f in
L2.normalize_weak5_lemma m f;
assert (as_nat5 r == as_nat5 f - v t4 / pow2 48 * S.prime);
Math.Lemmas.lemma_mod_sub (as_nat5 f) S.prime (v t4 / pow2 48)
let normalize5_lemma m f =
L2.normalize5_lemma m f
let fmul5_lemma a b =
L3.fmul5_lemma a b
let fmul5_lemma1 a b =
let r = fmul5 a b in
L3.fmul5_lemma a b;
assert (as_nat5 r % S.prime == as_nat5 a * as_nat5 b % S.prime);
ML.lemma_mod_mul_distr (as_nat5 a) (as_nat5 b) S.prime
let fsqr5_lemma a =
L3.fsqr5_lemma a | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.K256.MathLemmas.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas3.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas2.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas1.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.Lemmas.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.fst.checked",
"Hacl.Spec.K256.Field52.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.K256.Field52.Lemmas.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas3",
"short_module": "L3"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas2",
"short_module": "L2"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas1",
"short_module": "L1"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Definitions.Lemmas",
"short_module": "LD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.MathLemmas",
"short_module": "ML"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Hacl.Spec.K256.Field52.Definitions.felem5
-> FStar.Pervasives.Lemma
(requires Hacl.Spec.K256.Field52.Definitions.felem_fits5 a (64, 64, 64, 64, 64))
(ensures
(let res = Hacl.Spec.K256.Field52.fsqr5 a in
Hacl.Spec.K256.Field52.Definitions.feval5 res ==
Hacl.Spec.K256.Field52.Definitions.feval5 a * Hacl.Spec.K256.Field52.Definitions.feval5 a %
Spec.K256.PointOps.prime /\
Hacl.Spec.K256.Field52.Definitions.felem_fits5 res (1, 1, 1, 1, 2))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.K256.Field52.Definitions.felem5",
"Hacl.Spec.K256.MathLemmas.lemma_mod_mul_distr",
"Hacl.Spec.K256.Field52.Definitions.as_nat5",
"Spec.K256.PointOps.prime",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"Hacl.Spec.K256.Field52.Lemmas3.fsqr5_lemma",
"Hacl.Spec.K256.Field52.fsqr5"
] | [] | true | false | true | false | false | let fsqr5_lemma1 a =
| let r = fsqr5 a in
L3.fsqr5_lemma a;
assert (as_nat5 r % S.prime == as_nat5 a * as_nat5 a % S.prime);
ML.lemma_mod_mul_distr (as_nat5 a) (as_nat5 a) S.prime | false |
DependentBoolRefinement.fst | DependentBoolRefinement.elab_ty_open_commute' | val elab_ty_open_commute' (n: nat) (e: src_ty) (x: src_exp)
: Lemma (ensures RT.subst_term (elab_ty e) [RT.DT n (elab_exp x)] == elab_ty (open_ty' e x n))
(decreases e) | val elab_ty_open_commute' (n: nat) (e: src_ty) (x: src_exp)
: Lemma (ensures RT.subst_term (elab_ty e) [RT.DT n (elab_exp x)] == elab_ty (open_ty' e x n))
(decreases e) | let rec elab_open_commute' (n:nat) (e:src_exp) (x:src_exp)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.DT n (elab_exp x) ] ==
elab_exp (open_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| EIf b e1 e2 ->
elab_open_commute' n b x;
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| ELam t e ->
elab_ty_open_commute' n t x;
elab_open_commute' (n + 1) e x
and elab_ty_open_commute' (n:nat) (e:src_ty) (x:src_exp)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.DT n (elab_exp x) ] ==
elab_ty (open_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_open_commute' n t x;
elab_ty_open_commute' (n + 1) t' x
| TRefineBool e ->
elab_open_commute' (n + 1) e x | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 615,
"start_col": 0,
"start_line": 582
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1
let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1
let check_sub_typing f
(sg:src_env)
(t0 t1:src_ty)
: T.Tac (sub_typing f sg t0 t1)
= if t0 = t1 then S_Refl _ t0
else T.fail "Not subtypes"
let weaken (f:fstar_top_env) (sg:src_env) (hyp:var { None? (lookup sg hyp) } ) (b:src_exp) (t0 t1:src_ty)
: T.Tac (t:src_ty &
sub_typing f ((hyp,Inr(b, EBool true))::sg) t0 t &
sub_typing f ((hyp,Inr(b, EBool false))::sg) t1 t)
= if t0 = t1
then (| t0, S_Refl _ t0, S_Refl _ t1 |)
else T.fail "weaken is very dumb"
let ok (sg:src_env) (e:src_exp) = (forall x. x `Set.mem` freevars e ==> Some? (lookup sg x))
let ok_ty (sg:src_env) (e:src_ty) = (forall x. x `Set.mem` freevars_ty e ==> Some? (lookup sg x))
let rec check_ok_ty (t:src_ty) (sg:src_env)
: b:bool { b <==> (ok_ty sg t) }
= match t with
| TBool -> true
| TArrow t1 t2 ->
check_ok_ty t1 sg &&
check_ok_ty t2 sg
| TRefineBool e ->
check_ok e sg
and check_ok (e:src_exp) (sg:src_env)
: b:bool { b <==> ok sg e }
= match e with
| EBVar _ -> true
| EVar x -> Some? (lookup sg x)
| EBool _ -> true
| EIf b e1 e2 -> check_ok b sg && check_ok e1 sg && check_ok e2 sg
| ELam t e -> check_ok_ty t sg && check_ok e sg
| EApp e1 e2 -> check_ok e1 sg && check_ok e2 sg
#push-options "--fuel 2 --ifuel 2 --z3rlimit_factor 6 --query_stats"
let rec check (f:fstar_top_env)
(sg:src_env)
(e:src_exp { ok sg e })
: T.Tac (t:src_ty &
src_typing f sg e t)
= match e with
| EBVar _ ->
T.fail "Not locally nameless"
| EBool b ->
(| TBool, T_Bool _ b |)
| EVar n ->
begin
match lookup_ty sg n with
| None -> T.fail "Ill-typed"
| Some t ->
let d = T_Var sg n in
(| t, d |)
end
| ELam t body ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars body (EVar x) 0;
let (| tbody, dbody |) = check f ((x, Inl t)::sg) (open_exp body x) in
let dd : src_typing f sg e (TArrow t (close_ty tbody x)) =
T_Lam sg t body tbody x t_ok dbody in
(| TArrow t (close_ty tbody x), dd |)
| EApp e1 e2 ->
let (| t1, d1 |) = check f sg e1 in
let (| t2, d2 |) = check f sg e2 in
begin
match t1 with
| TArrow t_arg t_res ->
let st_ok = check_sub_typing f sg t2 t_arg in
(| open_ty_with t_res e2, T_App _ _ _ t_arg t_res _ d1 d2 st_ok |)
| _ ->
T.fail "Expected a function"
end
| EIf b e1 e2 ->
let (| tb, ok_b |) = check f sg b in
let hyp = fresh sg in
fresh_is_fresh sg;
if tb = TBool
then (
let (| t1, ok_1 |) = check f ((hyp, Inr(b, EBool true))::sg) e1 in
let (| t2, ok_2 |) = check f ((hyp, Inr(b, EBool false))::sg) e2 in
let (| t, w1, w2 |) = weaken f sg hyp b t1 t2 in
if not (check_ok_ty t sg)
then T.fail "Free variable escapes scope"
else (
let t_ok = check_ty f sg t in
(| t, T_If _ _ _ _ _ _ _ hyp ok_b ok_1 ok_2 w1 w2 t_ok |)
)
)
else T.fail "Branching on a non-boolean"
and check_ty (f:fstar_top_env)
(sg:src_env)
(t:src_ty { ok_ty sg t })
: T.Tac (src_ty_ok f sg t)
= match t with
| TBool -> OK_TBool _
| TArrow t t' ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_ty_freevars t' (EVar x) 0;
let t'_ok = check_ty f ((x, Inl t)::sg) (open_ty t' x) in
OK_TArrow _ _ _ x t_ok t'_ok
| TRefineBool e ->
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars e (EVar x) 0;
let (| te, de |) = check f ((x, Inl TBool)::sg) (open_exp e x) in
match te with
| TBool -> OK_TRefine sg e x de
| _ -> T.fail "Ill-typed refinement"
#pop-options
let rec extend_env_l_lookup_bvar (g:R.env) (sg:src_env) (x:var)
: Lemma
(requires (forall x. RT.lookup_bvar g x == None))
(ensures (
match lookup sg x with
| Some b -> RT.lookup_bvar (extend_env_l g sg) x == Some (elab_binding b)
| None -> RT.lookup_bvar (extend_env_l g sg) x == None))
(decreases sg)
[SMTPat (RT.lookup_bvar (extend_env_l g sg) x)]
= match sg with
| [] -> ()
| hd :: tl -> extend_env_l_lookup_bvar g tl x | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 8,
"initial_ifuel": 2,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 2,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | n: Prims.nat -> e: DependentBoolRefinement.src_ty -> x: DependentBoolRefinement.src_exp
-> FStar.Pervasives.Lemma
(ensures
FStar.Reflection.Typing.subst_term (DependentBoolRefinement.elab_ty e)
[FStar.Reflection.Typing.DT n (DependentBoolRefinement.elab_exp x)] ==
DependentBoolRefinement.elab_ty (DependentBoolRefinement.open_ty' e x n)) (decreases e) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [
"elab_open_commute'",
"elab_ty_open_commute'"
] | [
"Prims.nat",
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.elab_ty_open_commute'",
"Prims.op_Addition",
"Prims.unit",
"DependentBoolRefinement.elab_open_commute'",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Stubs.Reflection.Types.term",
"FStar.Reflection.Typing.subst_term",
"DependentBoolRefinement.elab_ty",
"Prims.Cons",
"FStar.Reflection.Typing.subst_elt",
"FStar.Reflection.Typing.DT",
"DependentBoolRefinement.elab_exp",
"Prims.Nil",
"DependentBoolRefinement.open_ty'",
"FStar.Pervasives.pattern"
] | [
"mutual recursion"
] | false | false | true | false | false | let rec elab_ty_open_commute' (n: nat) (e: src_ty) (x: src_exp)
: Lemma (ensures RT.subst_term (elab_ty e) [RT.DT n (elab_exp x)] == elab_ty (open_ty' e x n))
(decreases e) =
| match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_open_commute' n t x;
elab_ty_open_commute' (n + 1) t' x
| TRefineBool e -> elab_open_commute' (n + 1) e x | false |
DependentBoolRefinement.fst | DependentBoolRefinement.elab_open_commute' | val elab_open_commute' (n: nat) (e x: src_exp)
: Lemma
(ensures RT.subst_term (elab_exp e) [RT.DT n (elab_exp x)] == elab_exp (open_exp' e x n))
(decreases e) | val elab_open_commute' (n: nat) (e x: src_exp)
: Lemma
(ensures RT.subst_term (elab_exp e) [RT.DT n (elab_exp x)] == elab_exp (open_exp' e x n))
(decreases e) | let rec elab_open_commute' (n:nat) (e:src_exp) (x:src_exp)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.DT n (elab_exp x) ] ==
elab_exp (open_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| EIf b e1 e2 ->
elab_open_commute' n b x;
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| ELam t e ->
elab_ty_open_commute' n t x;
elab_open_commute' (n + 1) e x
and elab_ty_open_commute' (n:nat) (e:src_ty) (x:src_exp)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.DT n (elab_exp x) ] ==
elab_ty (open_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_open_commute' n t x;
elab_ty_open_commute' (n + 1) t' x
| TRefineBool e ->
elab_open_commute' (n + 1) e x | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 615,
"start_col": 0,
"start_line": 582
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1
let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1
let check_sub_typing f
(sg:src_env)
(t0 t1:src_ty)
: T.Tac (sub_typing f sg t0 t1)
= if t0 = t1 then S_Refl _ t0
else T.fail "Not subtypes"
let weaken (f:fstar_top_env) (sg:src_env) (hyp:var { None? (lookup sg hyp) } ) (b:src_exp) (t0 t1:src_ty)
: T.Tac (t:src_ty &
sub_typing f ((hyp,Inr(b, EBool true))::sg) t0 t &
sub_typing f ((hyp,Inr(b, EBool false))::sg) t1 t)
= if t0 = t1
then (| t0, S_Refl _ t0, S_Refl _ t1 |)
else T.fail "weaken is very dumb"
let ok (sg:src_env) (e:src_exp) = (forall x. x `Set.mem` freevars e ==> Some? (lookup sg x))
let ok_ty (sg:src_env) (e:src_ty) = (forall x. x `Set.mem` freevars_ty e ==> Some? (lookup sg x))
let rec check_ok_ty (t:src_ty) (sg:src_env)
: b:bool { b <==> (ok_ty sg t) }
= match t with
| TBool -> true
| TArrow t1 t2 ->
check_ok_ty t1 sg &&
check_ok_ty t2 sg
| TRefineBool e ->
check_ok e sg
and check_ok (e:src_exp) (sg:src_env)
: b:bool { b <==> ok sg e }
= match e with
| EBVar _ -> true
| EVar x -> Some? (lookup sg x)
| EBool _ -> true
| EIf b e1 e2 -> check_ok b sg && check_ok e1 sg && check_ok e2 sg
| ELam t e -> check_ok_ty t sg && check_ok e sg
| EApp e1 e2 -> check_ok e1 sg && check_ok e2 sg
#push-options "--fuel 2 --ifuel 2 --z3rlimit_factor 6 --query_stats"
let rec check (f:fstar_top_env)
(sg:src_env)
(e:src_exp { ok sg e })
: T.Tac (t:src_ty &
src_typing f sg e t)
= match e with
| EBVar _ ->
T.fail "Not locally nameless"
| EBool b ->
(| TBool, T_Bool _ b |)
| EVar n ->
begin
match lookup_ty sg n with
| None -> T.fail "Ill-typed"
| Some t ->
let d = T_Var sg n in
(| t, d |)
end
| ELam t body ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars body (EVar x) 0;
let (| tbody, dbody |) = check f ((x, Inl t)::sg) (open_exp body x) in
let dd : src_typing f sg e (TArrow t (close_ty tbody x)) =
T_Lam sg t body tbody x t_ok dbody in
(| TArrow t (close_ty tbody x), dd |)
| EApp e1 e2 ->
let (| t1, d1 |) = check f sg e1 in
let (| t2, d2 |) = check f sg e2 in
begin
match t1 with
| TArrow t_arg t_res ->
let st_ok = check_sub_typing f sg t2 t_arg in
(| open_ty_with t_res e2, T_App _ _ _ t_arg t_res _ d1 d2 st_ok |)
| _ ->
T.fail "Expected a function"
end
| EIf b e1 e2 ->
let (| tb, ok_b |) = check f sg b in
let hyp = fresh sg in
fresh_is_fresh sg;
if tb = TBool
then (
let (| t1, ok_1 |) = check f ((hyp, Inr(b, EBool true))::sg) e1 in
let (| t2, ok_2 |) = check f ((hyp, Inr(b, EBool false))::sg) e2 in
let (| t, w1, w2 |) = weaken f sg hyp b t1 t2 in
if not (check_ok_ty t sg)
then T.fail "Free variable escapes scope"
else (
let t_ok = check_ty f sg t in
(| t, T_If _ _ _ _ _ _ _ hyp ok_b ok_1 ok_2 w1 w2 t_ok |)
)
)
else T.fail "Branching on a non-boolean"
and check_ty (f:fstar_top_env)
(sg:src_env)
(t:src_ty { ok_ty sg t })
: T.Tac (src_ty_ok f sg t)
= match t with
| TBool -> OK_TBool _
| TArrow t t' ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_ty_freevars t' (EVar x) 0;
let t'_ok = check_ty f ((x, Inl t)::sg) (open_ty t' x) in
OK_TArrow _ _ _ x t_ok t'_ok
| TRefineBool e ->
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars e (EVar x) 0;
let (| te, de |) = check f ((x, Inl TBool)::sg) (open_exp e x) in
match te with
| TBool -> OK_TRefine sg e x de
| _ -> T.fail "Ill-typed refinement"
#pop-options
let rec extend_env_l_lookup_bvar (g:R.env) (sg:src_env) (x:var)
: Lemma
(requires (forall x. RT.lookup_bvar g x == None))
(ensures (
match lookup sg x with
| Some b -> RT.lookup_bvar (extend_env_l g sg) x == Some (elab_binding b)
| None -> RT.lookup_bvar (extend_env_l g sg) x == None))
(decreases sg)
[SMTPat (RT.lookup_bvar (extend_env_l g sg) x)]
= match sg with
| [] -> ()
| hd :: tl -> extend_env_l_lookup_bvar g tl x | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 8,
"initial_ifuel": 2,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 2,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | n: Prims.nat -> e: DependentBoolRefinement.src_exp -> x: DependentBoolRefinement.src_exp
-> FStar.Pervasives.Lemma
(ensures
FStar.Reflection.Typing.subst_term (DependentBoolRefinement.elab_exp e)
[FStar.Reflection.Typing.DT n (DependentBoolRefinement.elab_exp x)] ==
DependentBoolRefinement.elab_exp (DependentBoolRefinement.open_exp' e x n)) (decreases e) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [
"elab_open_commute'",
"elab_ty_open_commute'"
] | [
"Prims.nat",
"DependentBoolRefinement.src_exp",
"Prims.bool",
"DependentBoolRefinement.index",
"DependentBoolRefinement.var",
"DependentBoolRefinement.elab_open_commute'",
"Prims.unit",
"DependentBoolRefinement.src_ty",
"Prims.op_Addition",
"DependentBoolRefinement.elab_ty_open_commute'",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Stubs.Reflection.Types.term",
"FStar.Reflection.Typing.subst_term",
"DependentBoolRefinement.elab_exp",
"Prims.Cons",
"FStar.Reflection.Typing.subst_elt",
"FStar.Reflection.Typing.DT",
"Prims.Nil",
"DependentBoolRefinement.open_exp'",
"FStar.Pervasives.pattern"
] | [
"mutual recursion"
] | false | false | true | false | false | let rec elab_open_commute' (n: nat) (e x: src_exp)
: Lemma
(ensures RT.subst_term (elab_exp e) [RT.DT n (elab_exp x)] == elab_exp (open_exp' e x n))
(decreases e) =
| match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| EIf b e1 e2 ->
elab_open_commute' n b x;
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| ELam t e ->
elab_ty_open_commute' n t x;
elab_open_commute' (n + 1) e x | false |
Hacl.Spec.K256.Field52.Lemmas.fst | Hacl.Spec.K256.Field52.Lemmas.is_felem_eq_vartime5_lemma | val is_felem_eq_vartime5_lemma: f1:felem5 -> f2:felem5 -> Lemma
(requires felem_fits5 f1 (1,1,1,1,1) /\ felem_fits5 f2 (1,1,1,1,1))
(ensures is_felem_eq_vartime5 f1 f2 == (as_nat5 f1 = as_nat5 f2)) | val is_felem_eq_vartime5_lemma: f1:felem5 -> f2:felem5 -> Lemma
(requires felem_fits5 f1 (1,1,1,1,1) /\ felem_fits5 f2 (1,1,1,1,1))
(ensures is_felem_eq_vartime5 f1 f2 == (as_nat5 f1 = as_nat5 f2)) | let is_felem_eq_vartime5_lemma f1 f2 =
if as_nat5 f1 = as_nat5 f2 then LD.as_nat_inj f1 f2 | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 53,
"end_line": 77,
"start_col": 0,
"start_line": 76
} | module Hacl.Spec.K256.Field52.Lemmas
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
include Hacl.Spec.K256.Field52.Definitions
include Hacl.Spec.K256.Field52
module ML = Hacl.Spec.K256.MathLemmas
module LD = Hacl.Spec.K256.Field52.Definitions.Lemmas
module L1 = Hacl.Spec.K256.Field52.Lemmas1
module L2 = Hacl.Spec.K256.Field52.Lemmas2
module L3 = Hacl.Spec.K256.Field52.Lemmas3
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let load_felem5_lemma s =
L1.load_felem5_lemma s
let store_felem5_lemma f =
L1.store_felem5_lemma f
let add5_lemma m1 m2 f1 f2 =
L1.add5_lemma m1 m2 f1 f2
let fadd5_lemma m1 m2 f1 f2 =
let r = add5 f1 f2 in
add5_lemma m1 m2 f1 f2;
assert (as_nat5 r == as_nat5 f1 + as_nat5 f2);
Math.Lemmas.modulo_distributivity (as_nat5 f1) (as_nat5 f2) S.prime
let mul15_lemma m1 m2 f c =
L1.mul15_lemma m1 m2 f c
let fmul15_lemma m1 m2 f c =
let r = mul15 f c in
mul15_lemma m1 m2 f c;
assert (as_nat5 r == v c * as_nat5 f);
Math.Lemmas.lemma_mod_mul_distr_r (v c) (as_nat5 f) S.prime
#push-options "--ifuel 1"
let is_felem_zero_vartime5_lemma f = ()
let is_felem_ge_prime_vartime5_lemma f =
let p =
(u64 0xffffefffffc2f,
u64 0xfffffffffffff,
u64 0xfffffffffffff,
u64 0xfffffffffffff,
u64 0xffffffffffff) in
assert_norm (S.prime = as_nat5 p);
assert_norm (0xffffefffffc2f <= max52);
assert_norm (0xfffffffffffff = max52);
assert_norm (0xffffffffffff = max48);
assert (felem_fits5 p (1,1,1,1,1));
//LD.lemma_as_nat_decompose f;
//LD.lemma_as_nat_decompose p;
LD.lemma_as_nat_bound f;
LD.lemma_as_nat_bound p
let is_felem_lt_prime_minus_order_vartime5_lemma f =
assert_norm (S.prime - S.q =
0xda1722fc9baee + 0x1950b75fc4402 * pow52 + 0x1455123 * pow104) | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.K256.MathLemmas.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas3.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas2.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas1.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.Lemmas.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.fst.checked",
"Hacl.Spec.K256.Field52.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.K256.Field52.Lemmas.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas3",
"short_module": "L3"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas2",
"short_module": "L2"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas1",
"short_module": "L1"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Definitions.Lemmas",
"short_module": "LD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.MathLemmas",
"short_module": "ML"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | f1: Hacl.Spec.K256.Field52.Definitions.felem5 -> f2: Hacl.Spec.K256.Field52.Definitions.felem5
-> FStar.Pervasives.Lemma
(requires
Hacl.Spec.K256.Field52.Definitions.felem_fits5 f1 (1, 1, 1, 1, 1) /\
Hacl.Spec.K256.Field52.Definitions.felem_fits5 f2 (1, 1, 1, 1, 1))
(ensures
Hacl.Spec.K256.Field52.is_felem_eq_vartime5 f1 f2 ==
(Hacl.Spec.K256.Field52.Definitions.as_nat5 f1 =
Hacl.Spec.K256.Field52.Definitions.as_nat5 f2)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.K256.Field52.Definitions.felem5",
"Prims.op_Equality",
"Prims.nat",
"Hacl.Spec.K256.Field52.Definitions.as_nat5",
"Hacl.Spec.K256.Field52.Definitions.Lemmas.as_nat_inj",
"Prims.bool",
"Prims.unit"
] | [] | false | false | true | false | false | let is_felem_eq_vartime5_lemma f1 f2 =
| if as_nat5 f1 = as_nat5 f2 then LD.as_nat_inj f1 f2 | false |
Hacl.Spec.K256.Field52.Lemmas.fst | Hacl.Spec.K256.Field52.Lemmas.fsqr5_lemma | val fsqr5_lemma: a:felem5 -> Lemma
(requires
felem_fits5 a (64,64,64,64,64))
(ensures (let res = fsqr5 a in
as_nat5 res % S.prime == as_nat5 a * as_nat5 a % S.prime /\
felem_fits5 res (1,1,1,1,2))) | val fsqr5_lemma: a:felem5 -> Lemma
(requires
felem_fits5 a (64,64,64,64,64))
(ensures (let res = fsqr5 a in
as_nat5 res % S.prime == as_nat5 a * as_nat5 a % S.prime /\
felem_fits5 res (1,1,1,1,2))) | let fsqr5_lemma a =
L3.fsqr5_lemma a | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 18,
"end_line": 104,
"start_col": 0,
"start_line": 103
} | module Hacl.Spec.K256.Field52.Lemmas
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
include Hacl.Spec.K256.Field52.Definitions
include Hacl.Spec.K256.Field52
module ML = Hacl.Spec.K256.MathLemmas
module LD = Hacl.Spec.K256.Field52.Definitions.Lemmas
module L1 = Hacl.Spec.K256.Field52.Lemmas1
module L2 = Hacl.Spec.K256.Field52.Lemmas2
module L3 = Hacl.Spec.K256.Field52.Lemmas3
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let load_felem5_lemma s =
L1.load_felem5_lemma s
let store_felem5_lemma f =
L1.store_felem5_lemma f
let add5_lemma m1 m2 f1 f2 =
L1.add5_lemma m1 m2 f1 f2
let fadd5_lemma m1 m2 f1 f2 =
let r = add5 f1 f2 in
add5_lemma m1 m2 f1 f2;
assert (as_nat5 r == as_nat5 f1 + as_nat5 f2);
Math.Lemmas.modulo_distributivity (as_nat5 f1) (as_nat5 f2) S.prime
let mul15_lemma m1 m2 f c =
L1.mul15_lemma m1 m2 f c
let fmul15_lemma m1 m2 f c =
let r = mul15 f c in
mul15_lemma m1 m2 f c;
assert (as_nat5 r == v c * as_nat5 f);
Math.Lemmas.lemma_mod_mul_distr_r (v c) (as_nat5 f) S.prime
#push-options "--ifuel 1"
let is_felem_zero_vartime5_lemma f = ()
let is_felem_ge_prime_vartime5_lemma f =
let p =
(u64 0xffffefffffc2f,
u64 0xfffffffffffff,
u64 0xfffffffffffff,
u64 0xfffffffffffff,
u64 0xffffffffffff) in
assert_norm (S.prime = as_nat5 p);
assert_norm (0xffffefffffc2f <= max52);
assert_norm (0xfffffffffffff = max52);
assert_norm (0xffffffffffff = max48);
assert (felem_fits5 p (1,1,1,1,1));
//LD.lemma_as_nat_decompose f;
//LD.lemma_as_nat_decompose p;
LD.lemma_as_nat_bound f;
LD.lemma_as_nat_bound p
let is_felem_lt_prime_minus_order_vartime5_lemma f =
assert_norm (S.prime - S.q =
0xda1722fc9baee + 0x1950b75fc4402 * pow52 + 0x1455123 * pow104)
let is_felem_eq_vartime5_lemma f1 f2 =
if as_nat5 f1 = as_nat5 f2 then LD.as_nat_inj f1 f2
#pop-options
let normalize_weak5_lemma m f =
let r = normalize_weak5 f in
let (t0,t1,t2,t3,t4) = f in
L2.normalize_weak5_lemma m f;
assert (as_nat5 r == as_nat5 f - v t4 / pow2 48 * S.prime);
Math.Lemmas.lemma_mod_sub (as_nat5 f) S.prime (v t4 / pow2 48)
let normalize5_lemma m f =
L2.normalize5_lemma m f
let fmul5_lemma a b =
L3.fmul5_lemma a b
let fmul5_lemma1 a b =
let r = fmul5 a b in
L3.fmul5_lemma a b;
assert (as_nat5 r % S.prime == as_nat5 a * as_nat5 b % S.prime);
ML.lemma_mod_mul_distr (as_nat5 a) (as_nat5 b) S.prime | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.K256.MathLemmas.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas3.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas2.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas1.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.Lemmas.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.fst.checked",
"Hacl.Spec.K256.Field52.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.K256.Field52.Lemmas.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas3",
"short_module": "L3"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas2",
"short_module": "L2"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas1",
"short_module": "L1"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Definitions.Lemmas",
"short_module": "LD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.MathLemmas",
"short_module": "ML"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Hacl.Spec.K256.Field52.Definitions.felem5
-> FStar.Pervasives.Lemma
(requires Hacl.Spec.K256.Field52.Definitions.felem_fits5 a (64, 64, 64, 64, 64))
(ensures
(let res = Hacl.Spec.K256.Field52.fsqr5 a in
Hacl.Spec.K256.Field52.Definitions.as_nat5 res % Spec.K256.PointOps.prime ==
Hacl.Spec.K256.Field52.Definitions.as_nat5 a *
Hacl.Spec.K256.Field52.Definitions.as_nat5 a %
Spec.K256.PointOps.prime /\
Hacl.Spec.K256.Field52.Definitions.felem_fits5 res (1, 1, 1, 1, 2))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.K256.Field52.Definitions.felem5",
"Hacl.Spec.K256.Field52.Lemmas3.fsqr5_lemma",
"Prims.unit"
] | [] | true | false | true | false | false | let fsqr5_lemma a =
| L3.fsqr5_lemma a | false |
DependentBoolRefinement.fst | DependentBoolRefinement.elab_ty_close_commute' | val elab_ty_close_commute' (n: nat) (e: src_ty) (x: var)
: Lemma (ensures RT.subst_term (elab_ty e) [RT.ND x n] == elab_ty (close_ty' e x n))
(decreases e) | val elab_ty_close_commute' (n: nat) (e: src_ty) (x: var)
: Lemma (ensures RT.subst_term (elab_ty e) [RT.ND x n] == elab_ty (close_ty' e x n))
(decreases e) | let rec elab_close_commute' (n:nat) (e:src_exp) (x:var)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.ND x n ] ==
elab_exp (close_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_close_commute' n e1 x;
elab_close_commute' n e2 x
| EIf b e1 e2 ->
elab_close_commute' n b x;
elab_close_commute' n e1 x;
elab_close_commute' n e2 x
| ELam t e ->
elab_ty_close_commute' n t x;
elab_close_commute' (n + 1) e x
and elab_ty_close_commute' (n:nat) (e:src_ty) (x:var)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.ND x n ] ==
elab_ty (close_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_close_commute' n t x;
elab_ty_close_commute' (n + 1) t' x
| TRefineBool e ->
elab_close_commute' (n + 1) e x | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 37,
"end_line": 683,
"start_col": 0,
"start_line": 650
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1
let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1
let check_sub_typing f
(sg:src_env)
(t0 t1:src_ty)
: T.Tac (sub_typing f sg t0 t1)
= if t0 = t1 then S_Refl _ t0
else T.fail "Not subtypes"
let weaken (f:fstar_top_env) (sg:src_env) (hyp:var { None? (lookup sg hyp) } ) (b:src_exp) (t0 t1:src_ty)
: T.Tac (t:src_ty &
sub_typing f ((hyp,Inr(b, EBool true))::sg) t0 t &
sub_typing f ((hyp,Inr(b, EBool false))::sg) t1 t)
= if t0 = t1
then (| t0, S_Refl _ t0, S_Refl _ t1 |)
else T.fail "weaken is very dumb"
let ok (sg:src_env) (e:src_exp) = (forall x. x `Set.mem` freevars e ==> Some? (lookup sg x))
let ok_ty (sg:src_env) (e:src_ty) = (forall x. x `Set.mem` freevars_ty e ==> Some? (lookup sg x))
let rec check_ok_ty (t:src_ty) (sg:src_env)
: b:bool { b <==> (ok_ty sg t) }
= match t with
| TBool -> true
| TArrow t1 t2 ->
check_ok_ty t1 sg &&
check_ok_ty t2 sg
| TRefineBool e ->
check_ok e sg
and check_ok (e:src_exp) (sg:src_env)
: b:bool { b <==> ok sg e }
= match e with
| EBVar _ -> true
| EVar x -> Some? (lookup sg x)
| EBool _ -> true
| EIf b e1 e2 -> check_ok b sg && check_ok e1 sg && check_ok e2 sg
| ELam t e -> check_ok_ty t sg && check_ok e sg
| EApp e1 e2 -> check_ok e1 sg && check_ok e2 sg
#push-options "--fuel 2 --ifuel 2 --z3rlimit_factor 6 --query_stats"
let rec check (f:fstar_top_env)
(sg:src_env)
(e:src_exp { ok sg e })
: T.Tac (t:src_ty &
src_typing f sg e t)
= match e with
| EBVar _ ->
T.fail "Not locally nameless"
| EBool b ->
(| TBool, T_Bool _ b |)
| EVar n ->
begin
match lookup_ty sg n with
| None -> T.fail "Ill-typed"
| Some t ->
let d = T_Var sg n in
(| t, d |)
end
| ELam t body ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars body (EVar x) 0;
let (| tbody, dbody |) = check f ((x, Inl t)::sg) (open_exp body x) in
let dd : src_typing f sg e (TArrow t (close_ty tbody x)) =
T_Lam sg t body tbody x t_ok dbody in
(| TArrow t (close_ty tbody x), dd |)
| EApp e1 e2 ->
let (| t1, d1 |) = check f sg e1 in
let (| t2, d2 |) = check f sg e2 in
begin
match t1 with
| TArrow t_arg t_res ->
let st_ok = check_sub_typing f sg t2 t_arg in
(| open_ty_with t_res e2, T_App _ _ _ t_arg t_res _ d1 d2 st_ok |)
| _ ->
T.fail "Expected a function"
end
| EIf b e1 e2 ->
let (| tb, ok_b |) = check f sg b in
let hyp = fresh sg in
fresh_is_fresh sg;
if tb = TBool
then (
let (| t1, ok_1 |) = check f ((hyp, Inr(b, EBool true))::sg) e1 in
let (| t2, ok_2 |) = check f ((hyp, Inr(b, EBool false))::sg) e2 in
let (| t, w1, w2 |) = weaken f sg hyp b t1 t2 in
if not (check_ok_ty t sg)
then T.fail "Free variable escapes scope"
else (
let t_ok = check_ty f sg t in
(| t, T_If _ _ _ _ _ _ _ hyp ok_b ok_1 ok_2 w1 w2 t_ok |)
)
)
else T.fail "Branching on a non-boolean"
and check_ty (f:fstar_top_env)
(sg:src_env)
(t:src_ty { ok_ty sg t })
: T.Tac (src_ty_ok f sg t)
= match t with
| TBool -> OK_TBool _
| TArrow t t' ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_ty_freevars t' (EVar x) 0;
let t'_ok = check_ty f ((x, Inl t)::sg) (open_ty t' x) in
OK_TArrow _ _ _ x t_ok t'_ok
| TRefineBool e ->
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars e (EVar x) 0;
let (| te, de |) = check f ((x, Inl TBool)::sg) (open_exp e x) in
match te with
| TBool -> OK_TRefine sg e x de
| _ -> T.fail "Ill-typed refinement"
#pop-options
let rec extend_env_l_lookup_bvar (g:R.env) (sg:src_env) (x:var)
: Lemma
(requires (forall x. RT.lookup_bvar g x == None))
(ensures (
match lookup sg x with
| Some b -> RT.lookup_bvar (extend_env_l g sg) x == Some (elab_binding b)
| None -> RT.lookup_bvar (extend_env_l g sg) x == None))
(decreases sg)
[SMTPat (RT.lookup_bvar (extend_env_l g sg) x)]
= match sg with
| [] -> ()
| hd :: tl -> extend_env_l_lookup_bvar g tl x
#push-options "--query_stats --fuel 8 --ifuel 2 --z3rlimit_factor 2"
let rec elab_open_commute' (n:nat) (e:src_exp) (x:src_exp)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.DT n (elab_exp x) ] ==
elab_exp (open_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| EIf b e1 e2 ->
elab_open_commute' n b x;
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| ELam t e ->
elab_ty_open_commute' n t x;
elab_open_commute' (n + 1) e x
and elab_ty_open_commute' (n:nat) (e:src_ty) (x:src_exp)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.DT n (elab_exp x) ] ==
elab_ty (open_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_open_commute' n t x;
elab_ty_open_commute' (n + 1) t' x
| TRefineBool e ->
elab_open_commute' (n + 1) e x
#pop-options
let elab_open_commute (e:src_exp) (x:var)
: Lemma (RT.open_term (elab_exp e) x == elab_exp (open_exp e x))
[SMTPat (RT.open_term (elab_exp e) x)]
= elab_open_commute' 0 e (EVar x);
RT.open_term_spec (elab_exp e) x
let b2t_typing (g:fstar_env) (t:R.term) (dt:RT.tot_typing g t RT.bool_ty)
: RT.tot_typing g (r_b2t t) (RT.tm_type RT.u_zero)
= let b2t_typing : RT.tot_typing g _ b2t_ty = RT.T_FVar g b2t_fv in
let app_ty : _ = RT.T_App _ _ _ _ (RT.tm_type RT.u_zero) _ b2t_typing dt in
RT.open_with_spec (RT.tm_type RT.u_zero) t;
app_ty
let rec extend_env_l_lookup_fvar (g:R.env) (sg:src_env) (fv:R.fv)
: Lemma
(ensures
RT.lookup_fvar (extend_env_l g sg) fv ==
RT.lookup_fvar g fv)
[SMTPat (RT.lookup_fvar (extend_env_l g sg) fv)]
= match sg with
| [] -> ()
| hd::tl -> extend_env_l_lookup_fvar g tl fv
#push-options "--query_stats --fuel 2 --ifuel 2 --z3rlimit_factor 2"
let subtyping_soundness #f (#sg:src_env) (#t0 #t1:src_ty) (ds:sub_typing f sg t0 t1)
: GTot (RT.sub_typing (extend_env_l f sg) (elab_ty t0) (elab_ty t1))
= match ds with
| S_Refl _ _ -> RT.Rel_equiv _ _ _ _ (RT.Rel_refl _ _ _)
| S_ELab _ _ _ d -> d | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 8,
"initial_ifuel": 2,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 4,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | n: Prims.nat -> e: DependentBoolRefinement.src_ty -> x: DependentBoolRefinement.var
-> FStar.Pervasives.Lemma
(ensures
FStar.Reflection.Typing.subst_term (DependentBoolRefinement.elab_ty e)
[FStar.Reflection.Typing.ND x n] ==
DependentBoolRefinement.elab_ty (DependentBoolRefinement.close_ty' e x n)) (decreases e) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [
"elab_close_commute'",
"elab_ty_close_commute'"
] | [
"Prims.nat",
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.var",
"DependentBoolRefinement.elab_ty_close_commute'",
"Prims.op_Addition",
"Prims.unit",
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.elab_close_commute'",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Stubs.Reflection.Types.term",
"FStar.Reflection.Typing.subst_term",
"DependentBoolRefinement.elab_ty",
"Prims.Cons",
"FStar.Reflection.Typing.subst_elt",
"FStar.Reflection.Typing.ND",
"Prims.Nil",
"DependentBoolRefinement.close_ty'",
"FStar.Pervasives.pattern"
] | [
"mutual recursion"
] | false | false | true | false | false | let rec elab_ty_close_commute' (n: nat) (e: src_ty) (x: var)
: Lemma (ensures RT.subst_term (elab_ty e) [RT.ND x n] == elab_ty (close_ty' e x n))
(decreases e) =
| match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_close_commute' n t x;
elab_ty_close_commute' (n + 1) t' x
| TRefineBool e -> elab_close_commute' (n + 1) e x | false |
Hacl.Spec.K256.Field52.Lemmas.fst | Hacl.Spec.K256.Field52.Lemmas.is_felem_ge_prime_vartime5_lemma | val is_felem_ge_prime_vartime5_lemma: f:felem5 -> Lemma
(requires felem_fits5 f (1,1,1,1,1))
(ensures is_felem_ge_prime_vartime5 f == (as_nat5 f >= S.prime)) | val is_felem_ge_prime_vartime5_lemma: f:felem5 -> Lemma
(requires felem_fits5 f (1,1,1,1,1))
(ensures is_felem_ge_prime_vartime5 f == (as_nat5 f >= S.prime)) | let is_felem_ge_prime_vartime5_lemma f =
let p =
(u64 0xffffefffffc2f,
u64 0xfffffffffffff,
u64 0xfffffffffffff,
u64 0xfffffffffffff,
u64 0xffffffffffff) in
assert_norm (S.prime = as_nat5 p);
assert_norm (0xffffefffffc2f <= max52);
assert_norm (0xfffffffffffff = max52);
assert_norm (0xffffffffffff = max48);
assert (felem_fits5 p (1,1,1,1,1));
//LD.lemma_as_nat_decompose f;
//LD.lemma_as_nat_decompose p;
LD.lemma_as_nat_bound f;
LD.lemma_as_nat_bound p | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 25,
"end_line": 68,
"start_col": 0,
"start_line": 53
} | module Hacl.Spec.K256.Field52.Lemmas
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
include Hacl.Spec.K256.Field52.Definitions
include Hacl.Spec.K256.Field52
module ML = Hacl.Spec.K256.MathLemmas
module LD = Hacl.Spec.K256.Field52.Definitions.Lemmas
module L1 = Hacl.Spec.K256.Field52.Lemmas1
module L2 = Hacl.Spec.K256.Field52.Lemmas2
module L3 = Hacl.Spec.K256.Field52.Lemmas3
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let load_felem5_lemma s =
L1.load_felem5_lemma s
let store_felem5_lemma f =
L1.store_felem5_lemma f
let add5_lemma m1 m2 f1 f2 =
L1.add5_lemma m1 m2 f1 f2
let fadd5_lemma m1 m2 f1 f2 =
let r = add5 f1 f2 in
add5_lemma m1 m2 f1 f2;
assert (as_nat5 r == as_nat5 f1 + as_nat5 f2);
Math.Lemmas.modulo_distributivity (as_nat5 f1) (as_nat5 f2) S.prime
let mul15_lemma m1 m2 f c =
L1.mul15_lemma m1 m2 f c
let fmul15_lemma m1 m2 f c =
let r = mul15 f c in
mul15_lemma m1 m2 f c;
assert (as_nat5 r == v c * as_nat5 f);
Math.Lemmas.lemma_mod_mul_distr_r (v c) (as_nat5 f) S.prime
#push-options "--ifuel 1"
let is_felem_zero_vartime5_lemma f = () | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.K256.MathLemmas.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas3.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas2.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas1.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.Lemmas.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.fst.checked",
"Hacl.Spec.K256.Field52.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.K256.Field52.Lemmas.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas3",
"short_module": "L3"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas2",
"short_module": "L2"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas1",
"short_module": "L1"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Definitions.Lemmas",
"short_module": "LD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.MathLemmas",
"short_module": "ML"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | f: Hacl.Spec.K256.Field52.Definitions.felem5
-> FStar.Pervasives.Lemma
(requires Hacl.Spec.K256.Field52.Definitions.felem_fits5 f (1, 1, 1, 1, 1))
(ensures
Hacl.Spec.K256.Field52.is_felem_ge_prime_vartime5 f ==
(Hacl.Spec.K256.Field52.Definitions.as_nat5 f >= Spec.K256.PointOps.prime)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.K256.Field52.Definitions.felem5",
"Hacl.Spec.K256.Field52.Definitions.Lemmas.lemma_as_nat_bound",
"Prims.unit",
"Prims._assert",
"Hacl.Spec.K256.Field52.Definitions.felem_fits5",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Hacl.Spec.K256.Field52.Definitions.max48",
"Hacl.Spec.K256.Field52.Definitions.max52",
"Prims.op_LessThanOrEqual",
"Prims.l_or",
"Prims.l_and",
"Prims.op_GreaterThan",
"Prims.op_GreaterThanOrEqual",
"Spec.K256.PointOps.prime",
"Hacl.Spec.K256.Field52.Definitions.as_nat5",
"FStar.Pervasives.Native.tuple5",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Lib.IntTypes.uint64",
"Lib.IntTypes.u64"
] | [] | true | false | true | false | false | let is_felem_ge_prime_vartime5_lemma f =
| let p =
(u64 0xffffefffffc2f,
u64 0xfffffffffffff,
u64 0xfffffffffffff,
u64 0xfffffffffffff,
u64 0xffffffffffff)
in
assert_norm (S.prime = as_nat5 p);
assert_norm (0xffffefffffc2f <= max52);
assert_norm (0xfffffffffffff = max52);
assert_norm (0xffffffffffff = max48);
assert (felem_fits5 p (1, 1, 1, 1, 1));
LD.lemma_as_nat_bound f;
LD.lemma_as_nat_bound p | false |
DependentBoolRefinement.fst | DependentBoolRefinement.freevars_elab_exp | val freevars_elab_exp (e: src_exp) : Lemma ((freevars e) `Set.equal` (RT.freevars (elab_exp e))) | val freevars_elab_exp (e: src_exp) : Lemma ((freevars e) `Set.equal` (RT.freevars (elab_exp e))) | let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 25,
"end_line": 305,
"start_col": 0,
"start_line": 275
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | e: DependentBoolRefinement.src_exp
-> FStar.Pervasives.Lemma
(ensures
FStar.Set.equal (DependentBoolRefinement.freevars e)
(FStar.Reflection.Typing.freevars (DependentBoolRefinement.elab_exp e))) | FStar.Pervasives.Lemma | [
"lemma"
] | [
"freevars_elab_exp",
"freevars_elab_ty"
] | [
"DependentBoolRefinement.src_exp",
"Prims.bool",
"DependentBoolRefinement.index",
"DependentBoolRefinement.var",
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.freevars_elab_exp",
"Prims.unit",
"DependentBoolRefinement.freevars_elab_ty",
"Prims.l_True",
"Prims.squash",
"FStar.Set.equal",
"DependentBoolRefinement.freevars",
"FStar.Reflection.Typing.freevars",
"DependentBoolRefinement.elab_exp",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"mutual recursion"
] | false | false | true | false | false | let rec freevars_elab_exp (e: src_exp) : Lemma ((freevars e) `Set.equal` (RT.freevars (elab_exp e))) =
| match e with
| EBool _ | EBVar _ | EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2 | false |
DependentBoolRefinement.fst | DependentBoolRefinement.freevars_elab_ty | val freevars_elab_ty (t: src_ty) : Lemma ((freevars_ty t) `Set.equal` (RT.freevars (elab_ty t))) | val freevars_elab_ty (t: src_ty) : Lemma ((freevars_ty t) `Set.equal` (RT.freevars (elab_ty t))) | let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 25,
"end_line": 305,
"start_col": 0,
"start_line": 275
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | t: DependentBoolRefinement.src_ty
-> FStar.Pervasives.Lemma
(ensures
FStar.Set.equal (DependentBoolRefinement.freevars_ty t)
(FStar.Reflection.Typing.freevars (DependentBoolRefinement.elab_ty t))) | FStar.Pervasives.Lemma | [
"lemma"
] | [
"freevars_elab_exp",
"freevars_elab_ty"
] | [
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.freevars_elab_ty",
"Prims.unit",
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.freevars_elab_exp",
"Prims.l_True",
"Prims.squash",
"FStar.Set.equal",
"DependentBoolRefinement.var",
"DependentBoolRefinement.freevars_ty",
"FStar.Reflection.Typing.freevars",
"DependentBoolRefinement.elab_ty",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"mutual recursion"
] | false | false | true | false | false | let rec freevars_elab_ty (t: src_ty) : Lemma ((freevars_ty t) `Set.equal` (RT.freevars (elab_ty t))) =
| match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e -> freevars_elab_exp e | false |
Vale.Test.X64.Vale_memcpy.fsti | Vale.Test.X64.Vale_memcpy.va_quick_Memcpy | val va_quick_Memcpy (win: bool) (dst src: buffer64) : (va_quickCode unit (va_code_Memcpy win)) | val va_quick_Memcpy (win: bool) (dst src: buffer64) : (va_quickCode unit (va_code_Memcpy win)) | let va_quick_Memcpy (win:bool) (dst:buffer64) (src:buffer64) : (va_quickCode unit (va_code_Memcpy
win)) =
(va_QProc (va_code_Memcpy win) ([va_Mod_mem_heaplet 1; va_Mod_mem_layout; va_Mod_reg64 rR9;
va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) (va_wp_Memcpy win dst src)
(va_wpProof_Memcpy win dst src)) | {
"file_name": "obj/Vale.Test.X64.Vale_memcpy.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 36,
"end_line": 89,
"start_col": 0,
"start_line": 85
} | module Vale.Test.X64.Vale_memcpy
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
#set-options "--z3rlimit 20"
//-- Memcpy
val va_code_Memcpy : win:bool -> Tot va_code
val va_codegen_success_Memcpy : win:bool -> Tot va_pbool
let va_req_Memcpy (va_b0:va_code) (va_s0:va_state) (win:bool) (dst:buffer64) (src:buffer64) : prop =
(va_require_total va_b0 (va_code_Memcpy win) va_s0 /\ va_get_ok va_s0 /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
Vale.X64.Decls.locs_disjoint ([Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 dst;
Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 src]) /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem va_s0) (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) src 2
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (if win
then va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) dst 2 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.buffer_length #Vale.X64.Memory.vuint64 src == 2 /\
Vale.X64.Decls.buffer_length #Vale.X64.Memory.vuint64 dst == 2)
let va_ens_Memcpy (va_b0:va_code) (va_s0:va_state) (win:bool) (dst:buffer64) (src:buffer64)
(va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Memcpy va_b0 va_s0 win dst src /\ va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok
va_sM /\ Vale.X64.Memory.buffer_as_seq #Vale.X64.Memory.vuint64 (va_get_mem va_sM) dst ==
Vale.X64.Memory.buffer_as_seq #Vale.X64.Memory.vuint64 (va_get_mem va_sM) src /\
Vale.X64.Decls.modifies_mem (Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 dst)
(va_get_mem va_s0) (va_get_mem va_sM) /\ va_state_eq va_sM (va_update_mem_heaplet 1 va_sM
(va_update_mem_layout va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))
val va_lemma_Memcpy : va_b0:va_code -> va_s0:va_state -> win:bool -> dst:buffer64 -> src:buffer64
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Memcpy win) va_s0 /\ va_get_ok va_s0 /\
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
Vale.X64.Decls.locs_disjoint ([Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 dst;
Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 src]) /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem va_s0) (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) src 2
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem va_s0) (if win
then va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) dst 2 (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.buffer_length #Vale.X64.Memory.vuint64 src == 2 /\
Vale.X64.Decls.buffer_length #Vale.X64.Memory.vuint64 dst == 2))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.X64.Memory.buffer_as_seq #Vale.X64.Memory.vuint64 (va_get_mem va_sM) dst ==
Vale.X64.Memory.buffer_as_seq #Vale.X64.Memory.vuint64 (va_get_mem va_sM) src /\
Vale.X64.Decls.modifies_mem (Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 dst)
(va_get_mem va_s0) (va_get_mem va_sM) /\ va_state_eq va_sM (va_update_mem_heaplet 1 va_sM
(va_update_mem_layout va_sM (va_update_reg64 rR9 va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))
[@ va_qattr]
let va_wp_Memcpy (win:bool) (dst:buffer64) (src:buffer64) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0)
/\ Vale.X64.Decls.locs_disjoint ([Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 dst;
Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 src]) /\ Vale.X64.Decls.validSrcAddrs64
(va_get_mem va_s0) (va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi
va_s0)) src 2 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.validDstAddrs64 (va_get_mem
va_s0) (va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0)) dst 2
(va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.buffer_length #Vale.X64.Memory.vuint64 src
== 2 /\ Vale.X64.Decls.buffer_length #Vale.X64.Memory.vuint64 dst == 2 /\ (forall
(va_x_mem:vale_heap) (va_x_rax:nat64) (va_x_rcx:nat64) (va_x_r9:nat64)
(va_x_memLayout:vale_heap_layout) (va_x_heap1:vale_heap) . let va_sM = va_upd_mem_heaplet 1
va_x_heap1 (va_upd_mem_layout va_x_memLayout (va_upd_reg64 rR9 va_x_r9 (va_upd_reg64 rRcx
va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem va_x_mem va_s0))))) in va_get_ok va_sM /\
Vale.X64.Memory.buffer_as_seq #Vale.X64.Memory.vuint64 (va_get_mem va_sM) dst ==
Vale.X64.Memory.buffer_as_seq #Vale.X64.Memory.vuint64 (va_get_mem va_sM) src /\
Vale.X64.Decls.modifies_mem (Vale.X64.Decls.loc_buffer #Vale.X64.Memory.vuint64 dst)
(va_get_mem va_s0) (va_get_mem va_sM) ==> va_k va_sM (())))
val va_wpProof_Memcpy : win:bool -> dst:buffer64 -> src:buffer64 -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Memcpy win dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_Memcpy win) ([va_Mod_mem_heaplet 1;
va_Mod_mem_layout; va_Mod_reg64 rR9; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; va_Mod_mem]) va_s0
va_k ((va_sM, va_f0, va_g)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Test.X64.Vale_memcpy.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Test.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Test.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | win: Prims.bool -> dst: Vale.X64.Memory.buffer64 -> src: Vale.X64.Memory.buffer64
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.Test.X64.Vale_memcpy.va_code_Memcpy win) | Prims.Tot | [
"total"
] | [] | [
"Prims.bool",
"Vale.X64.Memory.buffer64",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.Test.X64.Vale_memcpy.va_code_Memcpy",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_mem_heaplet",
"Vale.X64.QuickCode.va_Mod_mem_layout",
"Vale.X64.QuickCode.va_Mod_reg64",
"Vale.X64.Machine_s.rR9",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRax",
"Vale.X64.QuickCode.va_Mod_mem",
"Prims.Nil",
"Vale.Test.X64.Vale_memcpy.va_wp_Memcpy",
"Vale.Test.X64.Vale_memcpy.va_wpProof_Memcpy",
"Vale.X64.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_Memcpy (win: bool) (dst src: buffer64) : (va_quickCode unit (va_code_Memcpy win)) =
| (va_QProc (va_code_Memcpy win)
([
va_Mod_mem_heaplet 1;
va_Mod_mem_layout;
va_Mod_reg64 rR9;
va_Mod_reg64 rRcx;
va_Mod_reg64 rRax;
va_Mod_mem
])
(va_wp_Memcpy win dst src)
(va_wpProof_Memcpy win dst src)) | false |
Hacl.Spec.K256.Field52.Lemmas.fst | Hacl.Spec.K256.Field52.Lemmas.sub5_lemma | val sub5_lemma (ma mb:scale64_5) (a b:felem5) (x:uint64) : Lemma
(requires (let xn = v x in
let (ma0,ma1,ma2,ma3,ma4) = ma in
let (mb0,mb1,mb2,mb3,mb4) = mb in 2 * xn <= 4096 /\
mb0 <= xn /\ mb1 <= xn /\ mb2 <= xn /\ mb3 <= xn /\ mb4 <= xn /\
ma0+2*xn <= 4096 /\ ma1+2*xn <= 4096 /\
ma2+2*xn <= 4096 /\ ma3+2*xn <= 4096 /\
ma4+2*xn <= 65536 /\
felem_fits5 a ma /\ felem_fits5 b mb))
(ensures (let r = fsub5 a b x in let xn = v x in
let (ma0,ma1,ma2,ma3,ma4) = ma in
as_nat5 r = as_nat5 a + 2 * xn * S.prime - as_nat5 b /\
felem_fits5 r (ma0+2*xn,ma1+2*xn,ma2+2*xn,ma3+2*xn,ma4+2*xn))) | val sub5_lemma (ma mb:scale64_5) (a b:felem5) (x:uint64) : Lemma
(requires (let xn = v x in
let (ma0,ma1,ma2,ma3,ma4) = ma in
let (mb0,mb1,mb2,mb3,mb4) = mb in 2 * xn <= 4096 /\
mb0 <= xn /\ mb1 <= xn /\ mb2 <= xn /\ mb3 <= xn /\ mb4 <= xn /\
ma0+2*xn <= 4096 /\ ma1+2*xn <= 4096 /\
ma2+2*xn <= 4096 /\ ma3+2*xn <= 4096 /\
ma4+2*xn <= 65536 /\
felem_fits5 a ma /\ felem_fits5 b mb))
(ensures (let r = fsub5 a b x in let xn = v x in
let (ma0,ma1,ma2,ma3,ma4) = ma in
as_nat5 r = as_nat5 a + 2 * xn * S.prime - as_nat5 b /\
felem_fits5 r (ma0+2*xn,ma1+2*xn,ma2+2*xn,ma3+2*xn,ma4+2*xn))) | let sub5_lemma ma mb a b x =
let (ma0,ma1,ma2,ma3,ma4) = ma in
let xn = v x in
let r = fnegate5 b x in
fnegate5_lemma mb b x;
let o = add5 a r in
add5_lemma ma (2*xn,2*xn,2*xn,2*xn,2*xn) a r | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 46,
"end_line": 225,
"start_col": 0,
"start_line": 219
} | module Hacl.Spec.K256.Field52.Lemmas
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
include Hacl.Spec.K256.Field52.Definitions
include Hacl.Spec.K256.Field52
module ML = Hacl.Spec.K256.MathLemmas
module LD = Hacl.Spec.K256.Field52.Definitions.Lemmas
module L1 = Hacl.Spec.K256.Field52.Lemmas1
module L2 = Hacl.Spec.K256.Field52.Lemmas2
module L3 = Hacl.Spec.K256.Field52.Lemmas3
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let load_felem5_lemma s =
L1.load_felem5_lemma s
let store_felem5_lemma f =
L1.store_felem5_lemma f
let add5_lemma m1 m2 f1 f2 =
L1.add5_lemma m1 m2 f1 f2
let fadd5_lemma m1 m2 f1 f2 =
let r = add5 f1 f2 in
add5_lemma m1 m2 f1 f2;
assert (as_nat5 r == as_nat5 f1 + as_nat5 f2);
Math.Lemmas.modulo_distributivity (as_nat5 f1) (as_nat5 f2) S.prime
let mul15_lemma m1 m2 f c =
L1.mul15_lemma m1 m2 f c
let fmul15_lemma m1 m2 f c =
let r = mul15 f c in
mul15_lemma m1 m2 f c;
assert (as_nat5 r == v c * as_nat5 f);
Math.Lemmas.lemma_mod_mul_distr_r (v c) (as_nat5 f) S.prime
#push-options "--ifuel 1"
let is_felem_zero_vartime5_lemma f = ()
let is_felem_ge_prime_vartime5_lemma f =
let p =
(u64 0xffffefffffc2f,
u64 0xfffffffffffff,
u64 0xfffffffffffff,
u64 0xfffffffffffff,
u64 0xffffffffffff) in
assert_norm (S.prime = as_nat5 p);
assert_norm (0xffffefffffc2f <= max52);
assert_norm (0xfffffffffffff = max52);
assert_norm (0xffffffffffff = max48);
assert (felem_fits5 p (1,1,1,1,1));
//LD.lemma_as_nat_decompose f;
//LD.lemma_as_nat_decompose p;
LD.lemma_as_nat_bound f;
LD.lemma_as_nat_bound p
let is_felem_lt_prime_minus_order_vartime5_lemma f =
assert_norm (S.prime - S.q =
0xda1722fc9baee + 0x1950b75fc4402 * pow52 + 0x1455123 * pow104)
let is_felem_eq_vartime5_lemma f1 f2 =
if as_nat5 f1 = as_nat5 f2 then LD.as_nat_inj f1 f2
#pop-options
let normalize_weak5_lemma m f =
let r = normalize_weak5 f in
let (t0,t1,t2,t3,t4) = f in
L2.normalize_weak5_lemma m f;
assert (as_nat5 r == as_nat5 f - v t4 / pow2 48 * S.prime);
Math.Lemmas.lemma_mod_sub (as_nat5 f) S.prime (v t4 / pow2 48)
let normalize5_lemma m f =
L2.normalize5_lemma m f
let fmul5_lemma a b =
L3.fmul5_lemma a b
let fmul5_lemma1 a b =
let r = fmul5 a b in
L3.fmul5_lemma a b;
assert (as_nat5 r % S.prime == as_nat5 a * as_nat5 b % S.prime);
ML.lemma_mod_mul_distr (as_nat5 a) (as_nat5 b) S.prime
let fsqr5_lemma a =
L3.fsqr5_lemma a
let fsqr5_lemma1 a =
let r = fsqr5 a in
L3.fsqr5_lemma a;
assert (as_nat5 r % S.prime == as_nat5 a * as_nat5 a % S.prime);
ML.lemma_mod_mul_distr (as_nat5 a) (as_nat5 a) S.prime
val lemma_mul_sub (mc:nat) (a b c:uint64) : Lemma
(requires
v a <= max52 /\ max52 <= v a * 2 /\ v c <= mc * max52 /\
mc <= v b /\ 2 * v b <= 4096)
(ensures (let r = a *. u64 2 *. b -. c in
v r = v a * 2 * v b - v c /\
felem_fits1 r (2 * v b)))
let lemma_mul_sub mc a b c =
let r = a *. u64 2 *. b -. c in
assert (v c <= mc * max52);
ML.lemma_ab_le_cd mc max52 (v b) (v a * 2);
assert (v c <= v a * 2 * v b);
assert (v a * 2 * v b - v c <= v a * 2 * v b);
Math.Lemmas.paren_mul_right (v a) 2 (v b);
ML.lemma_ab_le_cd (v a) (2 * v b) max52 4096;
assert_norm (4096 * max52 < pow2 64);
Math.Lemmas.small_mod (v a * 2 * v b - v c) (pow2 64);
assert (v r = v a * 2 * v b - v c);
ML.lemma_ab_le_cd (v a) (2 * v b) max52 (2 * v b);
assert (felem_fits1 r (2 * v b))
val lemma_mul_sub_last (mc:nat) (a b c:uint64) : Lemma
(requires
v a <= max48 /\ max48 <= v a * 2 /\ v c <= mc * max48 /\
mc <= v b /\ 2 * v b <= 65536)
(ensures (let r = a *. u64 2 *. b -. c in
v r = v a * 2 * v b - v c /\
felem_fits_last1 r (2 * v b)))
let lemma_mul_sub_last mc a b c =
let r = a *. u64 2 *. b -. c in
assert (v c <= mc * max48);
ML.lemma_ab_le_cd mc max48 (v b) (v a * 2);
assert (v c <= v b * (v a * 2));
assert (v a * 2 * v b - v c <= v a * 2 * v b);
Math.Lemmas.paren_mul_right (v a) 2 (v b);
ML.lemma_ab_le_cd (v a) (2 * v b) max48 65536;
assert_norm (65536 * max48 < pow2 64);
Math.Lemmas.small_mod (v a * 2 * v b - v c) (pow2 64);
assert (v r = v a * 2 * v b - v c);
ML.lemma_ab_le_cd (v a) (2 * v b) max48 (2 * v b);
assert (felem_fits_last1 r (2 * v b))
let fnegate5_lemma m a x =
let xn = v x in
let (a0,a1,a2,a3,a4) = a in
let (m0,m1,m2,m3,m4) = m in
let r0 = u64 0xffffefffffc2f *. u64 2 *. x -. a0 in
assert_norm (0xffffefffffc2f < max52);
assert_norm (max52 < 0xffffefffffc2f * 2);
lemma_mul_sub m0 (u64 0xffffefffffc2f) x a0;
let r1 = u64 0xfffffffffffff *. u64 2 *. x -. a1 in
assert_norm (0xfffffffffffff <= max52);
assert_norm (max52 <= 0xfffffffffffff * 2);
lemma_mul_sub m1 (u64 0xfffffffffffff) x a1;
let r2 = u64 0xfffffffffffff *. u64 2 *. x -. a2 in
lemma_mul_sub m2 (u64 0xfffffffffffff) x a2;
let r3 = u64 0xfffffffffffff *. u64 2 *. x -. a3 in
lemma_mul_sub m3 (u64 0xfffffffffffff) x a3;
let r4 = u64 0xffffffffffff *. u64 2 *. x -. a4 in
assert_norm (0xffffffffffff <= max48);
assert_norm (max48 <= 0xffffffffffff * 2);
lemma_mul_sub_last m4 (u64 0xffffffffffff) x a4;
let r = (r0,r1,r2,r3,r4) in
assert (felem_fits5 r (2*xn,2*xn,2*xn,2*xn,2*xn));
assert (as_nat5 r =
0xffffefffffc2f * 2 * v x - v a0 +
(0xfffffffffffff * 2 * v x - v a1) * pow52 +
(0xfffffffffffff * 2 * v x - v a2) * pow104 +
(0xfffffffffffff * 2 * v x - v a3) * pow156 +
(0xffffffffffff * 2 * v x - v a4) * pow208);
calc (==) {
0xffffefffffc2f * 2 * v x - v a0 +
(0xfffffffffffff * 2 * v x - v a1) * pow52 +
(0xfffffffffffff * 2 * v x - v a2) * pow104 +
(0xfffffffffffff * 2 * v x - v a3) * pow156 +
(0xffffffffffff * 2 * v x - v a4) * pow208;
(==) {
Math.Lemmas.paren_mul_right 0xffffefffffc2f 2 (v x);
Math.Lemmas.paren_mul_right 0xfffffffffffff 2 (v x);
Math.Lemmas.paren_mul_right 0xffffffffffff 2 (v x);
ML.lemma_distr5_pow52_sub (v a0) (v a1) (v a2) (v a3) (v a4)
0xffffefffffc2f 0xfffffffffffff 0xfffffffffffff 0xfffffffffffff 0xffffffffffff (2 * v x) }
- as_nat5 a + 2 * v x * (0xffffefffffc2f + 0xfffffffffffff * pow52 +
0xfffffffffffff * pow104 + 0xfffffffffffff * pow156 + 0xffffffffffff * pow208);
(==) { assert_norm (0xffffefffffc2f + 0xfffffffffffff * pow52 +
0xfffffffffffff * pow104 + 0xfffffffffffff * pow156 + 0xffffffffffff * pow208 = S.prime) }
- as_nat5 a + 2 * v x * S.prime;
};
assert (as_nat5 r = 2 * v x * S.prime - as_nat5 a) | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.K256.MathLemmas.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas3.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas2.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas1.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.Lemmas.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.fst.checked",
"Hacl.Spec.K256.Field52.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.K256.Field52.Lemmas.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas3",
"short_module": "L3"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas2",
"short_module": "L2"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas1",
"short_module": "L1"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Definitions.Lemmas",
"short_module": "LD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.MathLemmas",
"short_module": "ML"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
ma: Hacl.Spec.K256.Field52.Definitions.scale64_5 ->
mb: Hacl.Spec.K256.Field52.Definitions.scale64_5 ->
a: Hacl.Spec.K256.Field52.Definitions.felem5 ->
b: Hacl.Spec.K256.Field52.Definitions.felem5 ->
x: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(requires
(let xn = Lib.IntTypes.v x in
let _ = ma in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ ma0 ma1 ma2 ma3 ma4 = _ in
let _ = mb in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ mb0 mb1 mb2 mb3 mb4 = _ in
2 * xn <= 4096 /\ mb0 <= xn /\ mb1 <= xn /\ mb2 <= xn /\ mb3 <= xn /\ mb4 <= xn /\
ma0 + 2 * xn <= 4096 /\ ma1 + 2 * xn <= 4096 /\ ma2 + 2 * xn <= 4096 /\
ma3 + 2 * xn <= 4096 /\ ma4 + 2 * xn <= 65536 /\
Hacl.Spec.K256.Field52.Definitions.felem_fits5 a ma /\
Hacl.Spec.K256.Field52.Definitions.felem_fits5 b mb)
<:
Type0)
<:
Type0))
(ensures
(let r = Hacl.Spec.K256.Field52.fsub5 a b x in
let xn = Lib.IntTypes.v x in
let _ = ma in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ ma0 ma1 ma2 ma3 ma4 = _ in
Hacl.Spec.K256.Field52.Definitions.as_nat5 r =
Hacl.Spec.K256.Field52.Definitions.as_nat5 a + (2 * xn) * Spec.K256.PointOps.prime -
Hacl.Spec.K256.Field52.Definitions.as_nat5 b /\
Hacl.Spec.K256.Field52.Definitions.felem_fits5 r
(ma0 + 2 * xn,
ma1 + 2 * xn,
ma2 + 2 * xn,
ma3 + 2 * xn,
ma4 + 2 * xn))
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.K256.Field52.Definitions.scale64_5",
"Hacl.Spec.K256.Field52.Definitions.felem5",
"Lib.IntTypes.uint64",
"Prims.nat",
"Hacl.Spec.K256.Field52.Lemmas.add5_lemma",
"FStar.Pervasives.Native.Mktuple5",
"FStar.Mul.op_Star",
"Hacl.Spec.K256.Field52.add5",
"Prims.unit",
"Hacl.Spec.K256.Field52.Lemmas.fnegate5_lemma",
"Hacl.Spec.K256.Field52.fnegate5",
"Prims.int",
"Lib.IntTypes.range",
"Lib.IntTypes.U64",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC"
] | [] | false | false | true | false | false | let sub5_lemma ma mb a b x =
| let ma0, ma1, ma2, ma3, ma4 = ma in
let xn = v x in
let r = fnegate5 b x in
fnegate5_lemma mb b x;
let o = add5 a r in
add5_lemma ma (2 * xn, 2 * xn, 2 * xn, 2 * xn, 2 * xn) a r | false |
Hacl.Spec.K256.Field52.Lemmas.fst | Hacl.Spec.K256.Field52.Lemmas.fsub5_lemma | val fsub5_lemma (ma mb:scale64_5) (a b:felem5) (x:uint64) : Lemma
(requires (let xn = v x in
let (ma0,ma1,ma2,ma3,ma4) = ma in
let (mb0,mb1,mb2,mb3,mb4) = mb in 2 * xn <= 4096 /\
mb0 <= xn /\ mb1 <= xn /\ mb2 <= xn /\ mb3 <= xn /\ mb4 <= xn /\
ma0+2*xn <= 4096 /\ ma1+2*xn <= 4096 /\
ma2+2*xn <= 4096 /\ ma3+2*xn <= 4096 /\
ma4+2*xn <= 65536 /\
felem_fits5 a ma /\ felem_fits5 b mb))
(ensures (let r = fsub5 a b x in let xn = v x in
let (ma0,ma1,ma2,ma3,ma4) = ma in
feval5 r = (feval5 a - feval5 b) % S.prime /\
felem_fits5 r (ma0+2*xn,ma1+2*xn,ma2+2*xn,ma3+2*xn,ma4+2*xn))) | val fsub5_lemma (ma mb:scale64_5) (a b:felem5) (x:uint64) : Lemma
(requires (let xn = v x in
let (ma0,ma1,ma2,ma3,ma4) = ma in
let (mb0,mb1,mb2,mb3,mb4) = mb in 2 * xn <= 4096 /\
mb0 <= xn /\ mb1 <= xn /\ mb2 <= xn /\ mb3 <= xn /\ mb4 <= xn /\
ma0+2*xn <= 4096 /\ ma1+2*xn <= 4096 /\
ma2+2*xn <= 4096 /\ ma3+2*xn <= 4096 /\
ma4+2*xn <= 65536 /\
felem_fits5 a ma /\ felem_fits5 b mb))
(ensures (let r = fsub5 a b x in let xn = v x in
let (ma0,ma1,ma2,ma3,ma4) = ma in
feval5 r = (feval5 a - feval5 b) % S.prime /\
felem_fits5 r (ma0+2*xn,ma1+2*xn,ma2+2*xn,ma3+2*xn,ma4+2*xn))) | let fsub5_lemma ma mb a b x =
let r = fsub5 a b x in let xn = v x in
sub5_lemma ma mb a b x;
assert (as_nat5 r % S.prime = (as_nat5 a - as_nat5 b + 2 * xn * S.prime) % S.prime);
Math.Lemmas.lemma_mod_plus (as_nat5 a - as_nat5 b) (2 * xn) S.prime;
assert (as_nat5 r % S.prime = (as_nat5 a - as_nat5 b) % S.prime);
ML.lemma_mod_sub_distr (as_nat5 a) (as_nat5 b) S.prime | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 56,
"end_line": 234,
"start_col": 0,
"start_line": 228
} | module Hacl.Spec.K256.Field52.Lemmas
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
include Hacl.Spec.K256.Field52.Definitions
include Hacl.Spec.K256.Field52
module ML = Hacl.Spec.K256.MathLemmas
module LD = Hacl.Spec.K256.Field52.Definitions.Lemmas
module L1 = Hacl.Spec.K256.Field52.Lemmas1
module L2 = Hacl.Spec.K256.Field52.Lemmas2
module L3 = Hacl.Spec.K256.Field52.Lemmas3
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let load_felem5_lemma s =
L1.load_felem5_lemma s
let store_felem5_lemma f =
L1.store_felem5_lemma f
let add5_lemma m1 m2 f1 f2 =
L1.add5_lemma m1 m2 f1 f2
let fadd5_lemma m1 m2 f1 f2 =
let r = add5 f1 f2 in
add5_lemma m1 m2 f1 f2;
assert (as_nat5 r == as_nat5 f1 + as_nat5 f2);
Math.Lemmas.modulo_distributivity (as_nat5 f1) (as_nat5 f2) S.prime
let mul15_lemma m1 m2 f c =
L1.mul15_lemma m1 m2 f c
let fmul15_lemma m1 m2 f c =
let r = mul15 f c in
mul15_lemma m1 m2 f c;
assert (as_nat5 r == v c * as_nat5 f);
Math.Lemmas.lemma_mod_mul_distr_r (v c) (as_nat5 f) S.prime
#push-options "--ifuel 1"
let is_felem_zero_vartime5_lemma f = ()
let is_felem_ge_prime_vartime5_lemma f =
let p =
(u64 0xffffefffffc2f,
u64 0xfffffffffffff,
u64 0xfffffffffffff,
u64 0xfffffffffffff,
u64 0xffffffffffff) in
assert_norm (S.prime = as_nat5 p);
assert_norm (0xffffefffffc2f <= max52);
assert_norm (0xfffffffffffff = max52);
assert_norm (0xffffffffffff = max48);
assert (felem_fits5 p (1,1,1,1,1));
//LD.lemma_as_nat_decompose f;
//LD.lemma_as_nat_decompose p;
LD.lemma_as_nat_bound f;
LD.lemma_as_nat_bound p
let is_felem_lt_prime_minus_order_vartime5_lemma f =
assert_norm (S.prime - S.q =
0xda1722fc9baee + 0x1950b75fc4402 * pow52 + 0x1455123 * pow104)
let is_felem_eq_vartime5_lemma f1 f2 =
if as_nat5 f1 = as_nat5 f2 then LD.as_nat_inj f1 f2
#pop-options
let normalize_weak5_lemma m f =
let r = normalize_weak5 f in
let (t0,t1,t2,t3,t4) = f in
L2.normalize_weak5_lemma m f;
assert (as_nat5 r == as_nat5 f - v t4 / pow2 48 * S.prime);
Math.Lemmas.lemma_mod_sub (as_nat5 f) S.prime (v t4 / pow2 48)
let normalize5_lemma m f =
L2.normalize5_lemma m f
let fmul5_lemma a b =
L3.fmul5_lemma a b
let fmul5_lemma1 a b =
let r = fmul5 a b in
L3.fmul5_lemma a b;
assert (as_nat5 r % S.prime == as_nat5 a * as_nat5 b % S.prime);
ML.lemma_mod_mul_distr (as_nat5 a) (as_nat5 b) S.prime
let fsqr5_lemma a =
L3.fsqr5_lemma a
let fsqr5_lemma1 a =
let r = fsqr5 a in
L3.fsqr5_lemma a;
assert (as_nat5 r % S.prime == as_nat5 a * as_nat5 a % S.prime);
ML.lemma_mod_mul_distr (as_nat5 a) (as_nat5 a) S.prime
val lemma_mul_sub (mc:nat) (a b c:uint64) : Lemma
(requires
v a <= max52 /\ max52 <= v a * 2 /\ v c <= mc * max52 /\
mc <= v b /\ 2 * v b <= 4096)
(ensures (let r = a *. u64 2 *. b -. c in
v r = v a * 2 * v b - v c /\
felem_fits1 r (2 * v b)))
let lemma_mul_sub mc a b c =
let r = a *. u64 2 *. b -. c in
assert (v c <= mc * max52);
ML.lemma_ab_le_cd mc max52 (v b) (v a * 2);
assert (v c <= v a * 2 * v b);
assert (v a * 2 * v b - v c <= v a * 2 * v b);
Math.Lemmas.paren_mul_right (v a) 2 (v b);
ML.lemma_ab_le_cd (v a) (2 * v b) max52 4096;
assert_norm (4096 * max52 < pow2 64);
Math.Lemmas.small_mod (v a * 2 * v b - v c) (pow2 64);
assert (v r = v a * 2 * v b - v c);
ML.lemma_ab_le_cd (v a) (2 * v b) max52 (2 * v b);
assert (felem_fits1 r (2 * v b))
val lemma_mul_sub_last (mc:nat) (a b c:uint64) : Lemma
(requires
v a <= max48 /\ max48 <= v a * 2 /\ v c <= mc * max48 /\
mc <= v b /\ 2 * v b <= 65536)
(ensures (let r = a *. u64 2 *. b -. c in
v r = v a * 2 * v b - v c /\
felem_fits_last1 r (2 * v b)))
let lemma_mul_sub_last mc a b c =
let r = a *. u64 2 *. b -. c in
assert (v c <= mc * max48);
ML.lemma_ab_le_cd mc max48 (v b) (v a * 2);
assert (v c <= v b * (v a * 2));
assert (v a * 2 * v b - v c <= v a * 2 * v b);
Math.Lemmas.paren_mul_right (v a) 2 (v b);
ML.lemma_ab_le_cd (v a) (2 * v b) max48 65536;
assert_norm (65536 * max48 < pow2 64);
Math.Lemmas.small_mod (v a * 2 * v b - v c) (pow2 64);
assert (v r = v a * 2 * v b - v c);
ML.lemma_ab_le_cd (v a) (2 * v b) max48 (2 * v b);
assert (felem_fits_last1 r (2 * v b))
let fnegate5_lemma m a x =
let xn = v x in
let (a0,a1,a2,a3,a4) = a in
let (m0,m1,m2,m3,m4) = m in
let r0 = u64 0xffffefffffc2f *. u64 2 *. x -. a0 in
assert_norm (0xffffefffffc2f < max52);
assert_norm (max52 < 0xffffefffffc2f * 2);
lemma_mul_sub m0 (u64 0xffffefffffc2f) x a0;
let r1 = u64 0xfffffffffffff *. u64 2 *. x -. a1 in
assert_norm (0xfffffffffffff <= max52);
assert_norm (max52 <= 0xfffffffffffff * 2);
lemma_mul_sub m1 (u64 0xfffffffffffff) x a1;
let r2 = u64 0xfffffffffffff *. u64 2 *. x -. a2 in
lemma_mul_sub m2 (u64 0xfffffffffffff) x a2;
let r3 = u64 0xfffffffffffff *. u64 2 *. x -. a3 in
lemma_mul_sub m3 (u64 0xfffffffffffff) x a3;
let r4 = u64 0xffffffffffff *. u64 2 *. x -. a4 in
assert_norm (0xffffffffffff <= max48);
assert_norm (max48 <= 0xffffffffffff * 2);
lemma_mul_sub_last m4 (u64 0xffffffffffff) x a4;
let r = (r0,r1,r2,r3,r4) in
assert (felem_fits5 r (2*xn,2*xn,2*xn,2*xn,2*xn));
assert (as_nat5 r =
0xffffefffffc2f * 2 * v x - v a0 +
(0xfffffffffffff * 2 * v x - v a1) * pow52 +
(0xfffffffffffff * 2 * v x - v a2) * pow104 +
(0xfffffffffffff * 2 * v x - v a3) * pow156 +
(0xffffffffffff * 2 * v x - v a4) * pow208);
calc (==) {
0xffffefffffc2f * 2 * v x - v a0 +
(0xfffffffffffff * 2 * v x - v a1) * pow52 +
(0xfffffffffffff * 2 * v x - v a2) * pow104 +
(0xfffffffffffff * 2 * v x - v a3) * pow156 +
(0xffffffffffff * 2 * v x - v a4) * pow208;
(==) {
Math.Lemmas.paren_mul_right 0xffffefffffc2f 2 (v x);
Math.Lemmas.paren_mul_right 0xfffffffffffff 2 (v x);
Math.Lemmas.paren_mul_right 0xffffffffffff 2 (v x);
ML.lemma_distr5_pow52_sub (v a0) (v a1) (v a2) (v a3) (v a4)
0xffffefffffc2f 0xfffffffffffff 0xfffffffffffff 0xfffffffffffff 0xffffffffffff (2 * v x) }
- as_nat5 a + 2 * v x * (0xffffefffffc2f + 0xfffffffffffff * pow52 +
0xfffffffffffff * pow104 + 0xfffffffffffff * pow156 + 0xffffffffffff * pow208);
(==) { assert_norm (0xffffefffffc2f + 0xfffffffffffff * pow52 +
0xfffffffffffff * pow104 + 0xfffffffffffff * pow156 + 0xffffffffffff * pow208 = S.prime) }
- as_nat5 a + 2 * v x * S.prime;
};
assert (as_nat5 r = 2 * v x * S.prime - as_nat5 a)
let sub5_lemma ma mb a b x =
let (ma0,ma1,ma2,ma3,ma4) = ma in
let xn = v x in
let r = fnegate5 b x in
fnegate5_lemma mb b x;
let o = add5 a r in
add5_lemma ma (2*xn,2*xn,2*xn,2*xn,2*xn) a r | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.K256.MathLemmas.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas3.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas2.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas1.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.Lemmas.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.fst.checked",
"Hacl.Spec.K256.Field52.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.K256.Field52.Lemmas.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas3",
"short_module": "L3"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas2",
"short_module": "L2"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas1",
"short_module": "L1"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Definitions.Lemmas",
"short_module": "LD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.MathLemmas",
"short_module": "ML"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
ma: Hacl.Spec.K256.Field52.Definitions.scale64_5 ->
mb: Hacl.Spec.K256.Field52.Definitions.scale64_5 ->
a: Hacl.Spec.K256.Field52.Definitions.felem5 ->
b: Hacl.Spec.K256.Field52.Definitions.felem5 ->
x: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(requires
(let xn = Lib.IntTypes.v x in
let _ = ma in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ ma0 ma1 ma2 ma3 ma4 = _ in
let _ = mb in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ mb0 mb1 mb2 mb3 mb4 = _ in
2 * xn <= 4096 /\ mb0 <= xn /\ mb1 <= xn /\ mb2 <= xn /\ mb3 <= xn /\ mb4 <= xn /\
ma0 + 2 * xn <= 4096 /\ ma1 + 2 * xn <= 4096 /\ ma2 + 2 * xn <= 4096 /\
ma3 + 2 * xn <= 4096 /\ ma4 + 2 * xn <= 65536 /\
Hacl.Spec.K256.Field52.Definitions.felem_fits5 a ma /\
Hacl.Spec.K256.Field52.Definitions.felem_fits5 b mb)
<:
Type0)
<:
Type0))
(ensures
(let r = Hacl.Spec.K256.Field52.fsub5 a b x in
let xn = Lib.IntTypes.v x in
let _ = ma in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ ma0 ma1 ma2 ma3 ma4 = _ in
Hacl.Spec.K256.Field52.Definitions.feval5 r =
(Hacl.Spec.K256.Field52.Definitions.feval5 a -
Hacl.Spec.K256.Field52.Definitions.feval5 b) %
Spec.K256.PointOps.prime /\
Hacl.Spec.K256.Field52.Definitions.felem_fits5 r
(ma0 + 2 * xn,
ma1 + 2 * xn,
ma2 + 2 * xn,
ma3 + 2 * xn,
ma4 + 2 * xn))
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.K256.Field52.Definitions.scale64_5",
"Hacl.Spec.K256.Field52.Definitions.felem5",
"Lib.IntTypes.uint64",
"Hacl.Spec.K256.MathLemmas.lemma_mod_sub_distr",
"Hacl.Spec.K256.Field52.Definitions.as_nat5",
"Spec.K256.PointOps.prime",
"Prims.unit",
"Prims._assert",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"Prims.op_Subtraction",
"FStar.Math.Lemmas.lemma_mod_plus",
"FStar.Mul.op_Star",
"Prims.op_Addition",
"Hacl.Spec.K256.Field52.Lemmas.sub5_lemma",
"Lib.IntTypes.range",
"Lib.IntTypes.U64",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Hacl.Spec.K256.Field52.fsub5"
] | [] | true | false | true | false | false | let fsub5_lemma ma mb a b x =
| let r = fsub5 a b x in
let xn = v x in
sub5_lemma ma mb a b x;
assert (as_nat5 r % S.prime = (as_nat5 a - as_nat5 b + (2 * xn) * S.prime) % S.prime);
Math.Lemmas.lemma_mod_plus (as_nat5 a - as_nat5 b) (2 * xn) S.prime;
assert (as_nat5 r % S.prime = (as_nat5 a - as_nat5 b) % S.prime);
ML.lemma_mod_sub_distr (as_nat5 a) (as_nat5 b) S.prime | false |
Hacl.Spec.K256.Field52.Lemmas.fst | Hacl.Spec.K256.Field52.Lemmas.lemma_mul_sub | val lemma_mul_sub (mc:nat) (a b c:uint64) : Lemma
(requires
v a <= max52 /\ max52 <= v a * 2 /\ v c <= mc * max52 /\
mc <= v b /\ 2 * v b <= 4096)
(ensures (let r = a *. u64 2 *. b -. c in
v r = v a * 2 * v b - v c /\
felem_fits1 r (2 * v b))) | val lemma_mul_sub (mc:nat) (a b c:uint64) : Lemma
(requires
v a <= max52 /\ max52 <= v a * 2 /\ v c <= mc * max52 /\
mc <= v b /\ 2 * v b <= 4096)
(ensures (let r = a *. u64 2 *. b -. c in
v r = v a * 2 * v b - v c /\
felem_fits1 r (2 * v b))) | let lemma_mul_sub mc a b c =
let r = a *. u64 2 *. b -. c in
assert (v c <= mc * max52);
ML.lemma_ab_le_cd mc max52 (v b) (v a * 2);
assert (v c <= v a * 2 * v b);
assert (v a * 2 * v b - v c <= v a * 2 * v b);
Math.Lemmas.paren_mul_right (v a) 2 (v b);
ML.lemma_ab_le_cd (v a) (2 * v b) max52 4096;
assert_norm (4096 * max52 < pow2 64);
Math.Lemmas.small_mod (v a * 2 * v b - v c) (pow2 64);
assert (v r = v a * 2 * v b - v c);
ML.lemma_ab_le_cd (v a) (2 * v b) max52 (2 * v b);
assert (felem_fits1 r (2 * v b)) | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 34,
"end_line": 135,
"start_col": 0,
"start_line": 121
} | module Hacl.Spec.K256.Field52.Lemmas
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
include Hacl.Spec.K256.Field52.Definitions
include Hacl.Spec.K256.Field52
module ML = Hacl.Spec.K256.MathLemmas
module LD = Hacl.Spec.K256.Field52.Definitions.Lemmas
module L1 = Hacl.Spec.K256.Field52.Lemmas1
module L2 = Hacl.Spec.K256.Field52.Lemmas2
module L3 = Hacl.Spec.K256.Field52.Lemmas3
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
let load_felem5_lemma s =
L1.load_felem5_lemma s
let store_felem5_lemma f =
L1.store_felem5_lemma f
let add5_lemma m1 m2 f1 f2 =
L1.add5_lemma m1 m2 f1 f2
let fadd5_lemma m1 m2 f1 f2 =
let r = add5 f1 f2 in
add5_lemma m1 m2 f1 f2;
assert (as_nat5 r == as_nat5 f1 + as_nat5 f2);
Math.Lemmas.modulo_distributivity (as_nat5 f1) (as_nat5 f2) S.prime
let mul15_lemma m1 m2 f c =
L1.mul15_lemma m1 m2 f c
let fmul15_lemma m1 m2 f c =
let r = mul15 f c in
mul15_lemma m1 m2 f c;
assert (as_nat5 r == v c * as_nat5 f);
Math.Lemmas.lemma_mod_mul_distr_r (v c) (as_nat5 f) S.prime
#push-options "--ifuel 1"
let is_felem_zero_vartime5_lemma f = ()
let is_felem_ge_prime_vartime5_lemma f =
let p =
(u64 0xffffefffffc2f,
u64 0xfffffffffffff,
u64 0xfffffffffffff,
u64 0xfffffffffffff,
u64 0xffffffffffff) in
assert_norm (S.prime = as_nat5 p);
assert_norm (0xffffefffffc2f <= max52);
assert_norm (0xfffffffffffff = max52);
assert_norm (0xffffffffffff = max48);
assert (felem_fits5 p (1,1,1,1,1));
//LD.lemma_as_nat_decompose f;
//LD.lemma_as_nat_decompose p;
LD.lemma_as_nat_bound f;
LD.lemma_as_nat_bound p
let is_felem_lt_prime_minus_order_vartime5_lemma f =
assert_norm (S.prime - S.q =
0xda1722fc9baee + 0x1950b75fc4402 * pow52 + 0x1455123 * pow104)
let is_felem_eq_vartime5_lemma f1 f2 =
if as_nat5 f1 = as_nat5 f2 then LD.as_nat_inj f1 f2
#pop-options
let normalize_weak5_lemma m f =
let r = normalize_weak5 f in
let (t0,t1,t2,t3,t4) = f in
L2.normalize_weak5_lemma m f;
assert (as_nat5 r == as_nat5 f - v t4 / pow2 48 * S.prime);
Math.Lemmas.lemma_mod_sub (as_nat5 f) S.prime (v t4 / pow2 48)
let normalize5_lemma m f =
L2.normalize5_lemma m f
let fmul5_lemma a b =
L3.fmul5_lemma a b
let fmul5_lemma1 a b =
let r = fmul5 a b in
L3.fmul5_lemma a b;
assert (as_nat5 r % S.prime == as_nat5 a * as_nat5 b % S.prime);
ML.lemma_mod_mul_distr (as_nat5 a) (as_nat5 b) S.prime
let fsqr5_lemma a =
L3.fsqr5_lemma a
let fsqr5_lemma1 a =
let r = fsqr5 a in
L3.fsqr5_lemma a;
assert (as_nat5 r % S.prime == as_nat5 a * as_nat5 a % S.prime);
ML.lemma_mod_mul_distr (as_nat5 a) (as_nat5 a) S.prime
val lemma_mul_sub (mc:nat) (a b c:uint64) : Lemma
(requires
v a <= max52 /\ max52 <= v a * 2 /\ v c <= mc * max52 /\
mc <= v b /\ 2 * v b <= 4096)
(ensures (let r = a *. u64 2 *. b -. c in
v r = v a * 2 * v b - v c /\
felem_fits1 r (2 * v b))) | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.K256.MathLemmas.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas3.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas2.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas1.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.Lemmas.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.fst.checked",
"Hacl.Spec.K256.Field52.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Spec.K256.Field52.Lemmas.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas3",
"short_module": "L3"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas2",
"short_module": "L2"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas1",
"short_module": "L1"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Definitions.Lemmas",
"short_module": "LD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.MathLemmas",
"short_module": "ML"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | mc: Prims.nat -> a: Lib.IntTypes.uint64 -> b: Lib.IntTypes.uint64 -> c: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(requires
Lib.IntTypes.v a <= Hacl.Spec.K256.Field52.Definitions.max52 /\
Hacl.Spec.K256.Field52.Definitions.max52 <= Lib.IntTypes.v a * 2 /\
Lib.IntTypes.v c <= mc * Hacl.Spec.K256.Field52.Definitions.max52 /\ mc <= Lib.IntTypes.v b /\
2 * Lib.IntTypes.v b <= 4096)
(ensures
(let r = a *. Lib.IntTypes.u64 2 *. b -. c in
Lib.IntTypes.v r = (Lib.IntTypes.v a * 2) * Lib.IntTypes.v b - Lib.IntTypes.v c /\
Hacl.Spec.K256.Field52.Definitions.felem_fits1 r (2 * Lib.IntTypes.v b))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"Lib.IntTypes.uint64",
"Prims._assert",
"Prims.b2t",
"Hacl.Spec.K256.Field52.Definitions.felem_fits1",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.unit",
"Hacl.Spec.K256.MathLemmas.lemma_ab_le_cd",
"Hacl.Spec.K256.Field52.Definitions.max52",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Subtraction",
"FStar.Math.Lemmas.small_mod",
"Prims.pow2",
"FStar.Pervasives.assert_norm",
"Prims.op_LessThan",
"FStar.Math.Lemmas.paren_mul_right",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Subtraction_Dot",
"Lib.IntTypes.op_Star_Dot",
"Lib.IntTypes.u64"
] | [] | true | false | true | false | false | let lemma_mul_sub mc a b c =
| let r = a *. u64 2 *. b -. c in
assert (v c <= mc * max52);
ML.lemma_ab_le_cd mc max52 (v b) (v a * 2);
assert (v c <= (v a * 2) * v b);
assert ((v a * 2) * v b - v c <= (v a * 2) * v b);
Math.Lemmas.paren_mul_right (v a) 2 (v b);
ML.lemma_ab_le_cd (v a) (2 * v b) max52 4096;
assert_norm (4096 * max52 < pow2 64);
Math.Lemmas.small_mod ((v a * 2) * v b - v c) (pow2 64);
assert (v r = (v a * 2) * v b - v c);
ML.lemma_ab_le_cd (v a) (2 * v b) max52 (2 * v b);
assert (felem_fits1 r (2 * v b)) | false |
DependentBoolRefinement.fst | DependentBoolRefinement.soundness | val soundness
(#f: fstar_top_env)
(#sg: src_env{src_env_ok sg})
(#se: src_exp)
(#st: src_ty)
(dd: src_typing f sg se st)
: GTot (RT.tot_typing (extend_env_l f sg) (elab_exp se) (elab_ty st)) (decreases (height dd)) | val soundness
(#f: fstar_top_env)
(#sg: src_env{src_env_ok sg})
(#se: src_exp)
(#st: src_ty)
(dd: src_typing f sg se st)
: GTot (RT.tot_typing (extend_env_l f sg) (elab_exp se) (elab_ty st)) (decreases (height dd)) | let rec soundness (#f:fstar_top_env)
(#sg:src_env { src_env_ok sg } )
(#se:src_exp)
(#st:src_ty)
(dd:src_typing f sg se st)
: GTot (RT.tot_typing (extend_env_l f sg)
(elab_exp se)
(elab_ty st))
(decreases (height dd))
= match dd with
| T_Bool _ true ->
RT.T_Const _ _ _ RT.CT_True
| T_Bool _ false ->
RT.T_Const _ _ _ RT.CT_False
| T_Var _ x ->
RT.T_Var _ (R.pack_namedv (RT.make_namedv x))
| T_Lam _ t e t' x dt de ->
let de : RT.tot_typing (extend_env_l f ((x,Inl t)::sg))
(elab_exp (open_exp e x))
(elab_ty t')
= soundness de
in
let de : RT.tot_typing (RT.extend_env (extend_env_l f sg) x (elab_ty t))
(elab_exp (open_exp e x))
(elab_ty t')
= de
in
fresh_is_fresh sg;
freevars_elab_exp e;
let dt : RT.tot_typing (extend_env_l f sg) (elab_ty t) (RT.tm_type RT.u_zero) =
src_ty_ok_soundness sg t dt
in
let dd
: RT.tot_typing (extend_env_l f sg)
(R.pack_ln (R.Tv_Abs (RT.mk_simple_binder RT.pp_name_default (elab_ty t)) (elab_exp e)))
(elab_ty (TArrow t (close_ty t' x)))
= RT.close_term_spec (elab_ty t') x;
assert (elab_ty (close_ty t' x) ==
RT.subst_term (elab_ty t') [ RT.ND x 0 ]);
RT.T_Abs (extend_env_l f sg)
x
(elab_ty t)
(elab_exp e)
(T.E_Total, elab_ty t')
_
_
_
_
dt
de
in
dd
| T_If _ b e1 e2 t1 t2 t hyp db d1 d2 s1 s2 tok ->
let db = soundness db in
let d1 = soundness d1 in
let d2 = soundness d2 in
let s1 = subtyping_soundness s1 in
let s2 = subtyping_soundness s2 in
let t_ok = src_ty_ok_soundness sg t tok in
let d1 = RT.T_Sub _ _ _ _ d1 (RT.Relc_typ _ _ _ _ _ s1) in
let d2 = RT.T_Sub _ _ _ _ d2 (RT.Relc_typ _ _ _ _ _ s2) in
freevars_elab_exp e1;
freevars_elab_exp e2;
RT.T_If (extend_env_l f sg) (elab_exp b) (elab_exp e1) (elab_exp e2) _ _ hyp _ _ db d1 d2 t_ok
| T_App _ e1 e2 t t' t0 d1 d2 st ->
let dt1
: RT.tot_typing (extend_env_l f sg)
(elab_exp e1)
(elab_ty (TArrow t t'))
= soundness d1
in
let dt2
: RT.tot_typing (extend_env_l f sg)
(elab_exp e2)
(elab_ty t0)
= soundness d2
in
let st
: RT.sub_typing (extend_env_l f sg) (elab_ty t0) (elab_ty t)
= subtyping_soundness st
in
let dt2
: RT.tot_typing (extend_env_l f sg)
(elab_exp e2)
(elab_ty t)
= RT.T_Sub _ _ _ _ dt2 (RT.Relc_typ _ _ _ _ _ st)
in
RT.T_App _ _ _ _ (elab_ty t') _ dt1 dt2
and src_ty_ok_soundness (#f:fstar_top_env)
(sg:src_env { src_env_ok sg })
(t:src_ty)
(dt:src_ty_ok f sg t)
: GTot (RT.tot_typing (extend_env_l f sg) (elab_ty t) (RT.tm_type RT.u_zero))
(decreases (t_height dt))
= match dt with
| OK_TBool _ ->
RT.T_FVar _ RT.bool_fv
| OK_TArrow _ t1 t2 x ok_t1 ok_t2 ->
let t1_ok = src_ty_ok_soundness sg _ ok_t1 in
let t2_ok = src_ty_ok_soundness ((x, Inl t1)::sg) _ ok_t2 in
freevars_elab_ty t2;
let arr_max = RT.T_Arrow _ x (elab_ty t1) (elab_ty t2) _ _ RT.pp_name_default R.Q_Explicit T.E_Total _ _ t1_ok t2_ok in
RT.simplify_umax arr_max
| OK_TRefine _ e x de ->
let de
: RT.tot_typing (RT.extend_env (extend_env_l f sg) x RT.bool_ty)
(elab_exp (open_exp e x))
(elab_ty TBool)
= soundness de
in
let de
: RT.tot_typing (RT.extend_env (extend_env_l f sg) x RT.bool_ty)
(r_b2t (elab_exp (open_exp e x)))
(RT.tm_type RT.u_zero)
= b2t_typing _ _ de
in
let bool_typing
: RT.tot_typing (extend_env_l f sg) RT.bool_ty (RT.tm_type RT.u_zero)
= RT.T_FVar _ RT.bool_fv
in
elab_open_b2t e x;
freevars_elab_exp e;
RT.T_Refine (extend_env_l f sg)
x
RT.bool_ty
(r_b2t (elab_exp e))
_ _ _ _
bool_typing
de | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 19,
"end_line": 846,
"start_col": 0,
"start_line": 710
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1
let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1
let check_sub_typing f
(sg:src_env)
(t0 t1:src_ty)
: T.Tac (sub_typing f sg t0 t1)
= if t0 = t1 then S_Refl _ t0
else T.fail "Not subtypes"
let weaken (f:fstar_top_env) (sg:src_env) (hyp:var { None? (lookup sg hyp) } ) (b:src_exp) (t0 t1:src_ty)
: T.Tac (t:src_ty &
sub_typing f ((hyp,Inr(b, EBool true))::sg) t0 t &
sub_typing f ((hyp,Inr(b, EBool false))::sg) t1 t)
= if t0 = t1
then (| t0, S_Refl _ t0, S_Refl _ t1 |)
else T.fail "weaken is very dumb"
let ok (sg:src_env) (e:src_exp) = (forall x. x `Set.mem` freevars e ==> Some? (lookup sg x))
let ok_ty (sg:src_env) (e:src_ty) = (forall x. x `Set.mem` freevars_ty e ==> Some? (lookup sg x))
let rec check_ok_ty (t:src_ty) (sg:src_env)
: b:bool { b <==> (ok_ty sg t) }
= match t with
| TBool -> true
| TArrow t1 t2 ->
check_ok_ty t1 sg &&
check_ok_ty t2 sg
| TRefineBool e ->
check_ok e sg
and check_ok (e:src_exp) (sg:src_env)
: b:bool { b <==> ok sg e }
= match e with
| EBVar _ -> true
| EVar x -> Some? (lookup sg x)
| EBool _ -> true
| EIf b e1 e2 -> check_ok b sg && check_ok e1 sg && check_ok e2 sg
| ELam t e -> check_ok_ty t sg && check_ok e sg
| EApp e1 e2 -> check_ok e1 sg && check_ok e2 sg
#push-options "--fuel 2 --ifuel 2 --z3rlimit_factor 6 --query_stats"
let rec check (f:fstar_top_env)
(sg:src_env)
(e:src_exp { ok sg e })
: T.Tac (t:src_ty &
src_typing f sg e t)
= match e with
| EBVar _ ->
T.fail "Not locally nameless"
| EBool b ->
(| TBool, T_Bool _ b |)
| EVar n ->
begin
match lookup_ty sg n with
| None -> T.fail "Ill-typed"
| Some t ->
let d = T_Var sg n in
(| t, d |)
end
| ELam t body ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars body (EVar x) 0;
let (| tbody, dbody |) = check f ((x, Inl t)::sg) (open_exp body x) in
let dd : src_typing f sg e (TArrow t (close_ty tbody x)) =
T_Lam sg t body tbody x t_ok dbody in
(| TArrow t (close_ty tbody x), dd |)
| EApp e1 e2 ->
let (| t1, d1 |) = check f sg e1 in
let (| t2, d2 |) = check f sg e2 in
begin
match t1 with
| TArrow t_arg t_res ->
let st_ok = check_sub_typing f sg t2 t_arg in
(| open_ty_with t_res e2, T_App _ _ _ t_arg t_res _ d1 d2 st_ok |)
| _ ->
T.fail "Expected a function"
end
| EIf b e1 e2 ->
let (| tb, ok_b |) = check f sg b in
let hyp = fresh sg in
fresh_is_fresh sg;
if tb = TBool
then (
let (| t1, ok_1 |) = check f ((hyp, Inr(b, EBool true))::sg) e1 in
let (| t2, ok_2 |) = check f ((hyp, Inr(b, EBool false))::sg) e2 in
let (| t, w1, w2 |) = weaken f sg hyp b t1 t2 in
if not (check_ok_ty t sg)
then T.fail "Free variable escapes scope"
else (
let t_ok = check_ty f sg t in
(| t, T_If _ _ _ _ _ _ _ hyp ok_b ok_1 ok_2 w1 w2 t_ok |)
)
)
else T.fail "Branching on a non-boolean"
and check_ty (f:fstar_top_env)
(sg:src_env)
(t:src_ty { ok_ty sg t })
: T.Tac (src_ty_ok f sg t)
= match t with
| TBool -> OK_TBool _
| TArrow t t' ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_ty_freevars t' (EVar x) 0;
let t'_ok = check_ty f ((x, Inl t)::sg) (open_ty t' x) in
OK_TArrow _ _ _ x t_ok t'_ok
| TRefineBool e ->
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars e (EVar x) 0;
let (| te, de |) = check f ((x, Inl TBool)::sg) (open_exp e x) in
match te with
| TBool -> OK_TRefine sg e x de
| _ -> T.fail "Ill-typed refinement"
#pop-options
let rec extend_env_l_lookup_bvar (g:R.env) (sg:src_env) (x:var)
: Lemma
(requires (forall x. RT.lookup_bvar g x == None))
(ensures (
match lookup sg x with
| Some b -> RT.lookup_bvar (extend_env_l g sg) x == Some (elab_binding b)
| None -> RT.lookup_bvar (extend_env_l g sg) x == None))
(decreases sg)
[SMTPat (RT.lookup_bvar (extend_env_l g sg) x)]
= match sg with
| [] -> ()
| hd :: tl -> extend_env_l_lookup_bvar g tl x
#push-options "--query_stats --fuel 8 --ifuel 2 --z3rlimit_factor 2"
let rec elab_open_commute' (n:nat) (e:src_exp) (x:src_exp)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.DT n (elab_exp x) ] ==
elab_exp (open_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| EIf b e1 e2 ->
elab_open_commute' n b x;
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| ELam t e ->
elab_ty_open_commute' n t x;
elab_open_commute' (n + 1) e x
and elab_ty_open_commute' (n:nat) (e:src_ty) (x:src_exp)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.DT n (elab_exp x) ] ==
elab_ty (open_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_open_commute' n t x;
elab_ty_open_commute' (n + 1) t' x
| TRefineBool e ->
elab_open_commute' (n + 1) e x
#pop-options
let elab_open_commute (e:src_exp) (x:var)
: Lemma (RT.open_term (elab_exp e) x == elab_exp (open_exp e x))
[SMTPat (RT.open_term (elab_exp e) x)]
= elab_open_commute' 0 e (EVar x);
RT.open_term_spec (elab_exp e) x
let b2t_typing (g:fstar_env) (t:R.term) (dt:RT.tot_typing g t RT.bool_ty)
: RT.tot_typing g (r_b2t t) (RT.tm_type RT.u_zero)
= let b2t_typing : RT.tot_typing g _ b2t_ty = RT.T_FVar g b2t_fv in
let app_ty : _ = RT.T_App _ _ _ _ (RT.tm_type RT.u_zero) _ b2t_typing dt in
RT.open_with_spec (RT.tm_type RT.u_zero) t;
app_ty
let rec extend_env_l_lookup_fvar (g:R.env) (sg:src_env) (fv:R.fv)
: Lemma
(ensures
RT.lookup_fvar (extend_env_l g sg) fv ==
RT.lookup_fvar g fv)
[SMTPat (RT.lookup_fvar (extend_env_l g sg) fv)]
= match sg with
| [] -> ()
| hd::tl -> extend_env_l_lookup_fvar g tl fv
#push-options "--query_stats --fuel 2 --ifuel 2 --z3rlimit_factor 2"
let subtyping_soundness #f (#sg:src_env) (#t0 #t1:src_ty) (ds:sub_typing f sg t0 t1)
: GTot (RT.sub_typing (extend_env_l f sg) (elab_ty t0) (elab_ty t1))
= match ds with
| S_Refl _ _ -> RT.Rel_equiv _ _ _ _ (RT.Rel_refl _ _ _)
| S_ELab _ _ _ d -> d
#push-options "--query_stats --fuel 8 --ifuel 2 --z3rlimit_factor 4"
let rec elab_close_commute' (n:nat) (e:src_exp) (x:var)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.ND x n ] ==
elab_exp (close_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_close_commute' n e1 x;
elab_close_commute' n e2 x
| EIf b e1 e2 ->
elab_close_commute' n b x;
elab_close_commute' n e1 x;
elab_close_commute' n e2 x
| ELam t e ->
elab_ty_close_commute' n t x;
elab_close_commute' (n + 1) e x
and elab_ty_close_commute' (n:nat) (e:src_ty) (x:var)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.ND x n ] ==
elab_ty (close_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_close_commute' n t x;
elab_ty_close_commute' (n + 1) t' x
| TRefineBool e ->
elab_close_commute' (n + 1) e x
#pop-options
let elab_ty_close_commute (e:src_ty) (x:var)
: Lemma (RT.close_term (elab_ty e) x == elab_ty (close_ty e x))
[SMTPat (RT.close_term (elab_ty e) x)]
= RT.close_term_spec (elab_ty e) x;
elab_ty_close_commute' 0 e x
let elab_ty_open_with_commute (e:src_ty) (v:src_exp)
: Lemma (RT.open_with (elab_ty e) (elab_exp v) == elab_ty (open_ty_with e v))
[SMTPat (RT.open_with (elab_ty e) (elab_exp v))]
= elab_ty_open_commute' 0 e v;
RT.open_with_spec (elab_ty e) (elab_exp v)
let elab_ty_open_commute (e:src_ty) (v:var)
: Lemma (RT.open_term (elab_ty e) v == elab_ty (open_ty e v))
[SMTPat (RT.open_term (elab_ty e) v)]
= elab_ty_open_commute' 0 e (EVar v);
RT.open_term_spec (elab_ty e) v
let elab_open_b2t (e:src_exp) (x:var)
: Lemma (RT.open_term (r_b2t (elab_exp e)) x ==
r_b2t (elab_exp (open_exp e x)))
= RT.open_term_spec (r_b2t (elab_exp e)) x;
RT.open_term_spec (elab_exp e) x | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 2,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 2,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | dd: DependentBoolRefinement.src_typing f sg se st
-> Prims.GTot
(FStar.Reflection.Typing.tot_typing (DependentBoolRefinement.extend_env_l f sg)
(DependentBoolRefinement.elab_exp se)
(DependentBoolRefinement.elab_ty st)) | Prims.GTot | [
"sometrivial",
""
] | [
"soundness",
"src_ty_ok_soundness"
] | [
"DependentBoolRefinement.fstar_top_env",
"DependentBoolRefinement.src_env",
"Prims.b2t",
"DependentBoolRefinement.src_env_ok",
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.src_typing",
"FStar.Reflection.Typing.T_Const",
"DependentBoolRefinement.extend_env_l",
"FStar.Stubs.Reflection.V2.Data.C_True",
"FStar.Reflection.Typing.bool_ty",
"FStar.Reflection.Typing.CT_True",
"FStar.Stubs.Reflection.V2.Data.C_False",
"FStar.Reflection.Typing.CT_False",
"DependentBoolRefinement.var",
"FStar.Pervasives.Native.uu___is_Some",
"DependentBoolRefinement.lookup_ty",
"FStar.Reflection.Typing.T_Var",
"FStar.Stubs.Reflection.V2.Builtins.pack_namedv",
"FStar.Reflection.Typing.make_namedv",
"Prims.l_and",
"FStar.Pervasives.Native.uu___is_None",
"DependentBoolRefinement.binding",
"DependentBoolRefinement.lookup",
"Prims.l_not",
"FStar.Set.mem",
"DependentBoolRefinement.freevars",
"DependentBoolRefinement.src_ty_ok",
"Prims.Cons",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Inl",
"DependentBoolRefinement.src_eqn",
"DependentBoolRefinement.open_exp",
"FStar.Reflection.Typing.tot_typing",
"FStar.Stubs.Reflection.V2.Builtins.pack_ln",
"FStar.Stubs.Reflection.V2.Data.Tv_Abs",
"FStar.Reflection.Typing.mk_simple_binder",
"FStar.Reflection.Typing.pp_name_default",
"DependentBoolRefinement.elab_ty",
"DependentBoolRefinement.elab_exp",
"DependentBoolRefinement.TArrow",
"DependentBoolRefinement.close_ty",
"FStar.Reflection.Typing.T_Abs",
"FStar.Stubs.TypeChecker.Core.tot_or_ghost",
"FStar.Stubs.Reflection.Types.typ",
"FStar.Stubs.TypeChecker.Core.E_Total",
"FStar.Reflection.Typing.u_zero",
"FStar.Stubs.Reflection.V2.Data.Q_Explicit",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"FStar.Stubs.Reflection.Types.term",
"FStar.Reflection.Typing.subst_term",
"FStar.Reflection.Typing.subst_elt",
"FStar.Reflection.Typing.ND",
"Prims.Nil",
"FStar.Reflection.Typing.close_term_spec",
"FStar.Reflection.Typing.tm_type",
"DependentBoolRefinement.src_ty_ok_soundness",
"DependentBoolRefinement.freevars_elab_exp",
"DependentBoolRefinement.fresh_is_fresh",
"FStar.Reflection.Typing.extend_env",
"DependentBoolRefinement.soundness",
"DependentBoolRefinement.TBool",
"FStar.Pervasives.Inr",
"DependentBoolRefinement.EBool",
"DependentBoolRefinement.sub_typing",
"FStar.Reflection.Typing.T_If",
"FStar.Reflection.Typing.typing",
"FStar.Reflection.Typing.T_Sub",
"FStar.Reflection.Typing.Relc_typ",
"FStar.Reflection.Typing.R_Sub",
"FStar.Reflection.Typing.sub_typing",
"DependentBoolRefinement.subtyping_soundness",
"FStar.Reflection.Typing.T_App"
] | [
"mutual recursion"
] | false | false | false | false | false | let rec soundness
(#f: fstar_top_env)
(#sg: src_env{src_env_ok sg})
(#se: src_exp)
(#st: src_ty)
(dd: src_typing f sg se st)
: GTot (RT.tot_typing (extend_env_l f sg) (elab_exp se) (elab_ty st)) (decreases (height dd)) =
| match dd with
| T_Bool _ true -> RT.T_Const _ _ _ RT.CT_True
| T_Bool _ false -> RT.T_Const _ _ _ RT.CT_False
| T_Var _ x -> RT.T_Var _ (R.pack_namedv (RT.make_namedv x))
| T_Lam _ t e t' x dt de ->
let de:RT.tot_typing (extend_env_l f ((x, Inl t) :: sg)) (elab_exp (open_exp e x)) (elab_ty t') =
soundness de
in
let de:RT.tot_typing (RT.extend_env (extend_env_l f sg) x (elab_ty t))
(elab_exp (open_exp e x))
(elab_ty t') =
de
in
fresh_is_fresh sg;
freevars_elab_exp e;
let dt:RT.tot_typing (extend_env_l f sg) (elab_ty t) (RT.tm_type RT.u_zero) =
src_ty_ok_soundness sg t dt
in
let dd:RT.tot_typing (extend_env_l f sg)
(R.pack_ln (R.Tv_Abs (RT.mk_simple_binder RT.pp_name_default (elab_ty t)) (elab_exp e)))
(elab_ty (TArrow t (close_ty t' x))) =
RT.close_term_spec (elab_ty t') x;
assert (elab_ty (close_ty t' x) == RT.subst_term (elab_ty t') [RT.ND x 0]);
RT.T_Abs (extend_env_l f sg) x (elab_ty t) (elab_exp e) (T.E_Total, elab_ty t') _ _ _ _ dt de
in
dd
| T_If _ b e1 e2 t1 t2 t hyp db d1 d2 s1 s2 tok ->
let db = soundness db in
let d1 = soundness d1 in
let d2 = soundness d2 in
let s1 = subtyping_soundness s1 in
let s2 = subtyping_soundness s2 in
let t_ok = src_ty_ok_soundness sg t tok in
let d1 = RT.T_Sub _ _ _ _ d1 (RT.Relc_typ _ _ _ _ _ s1) in
let d2 = RT.T_Sub _ _ _ _ d2 (RT.Relc_typ _ _ _ _ _ s2) in
freevars_elab_exp e1;
freevars_elab_exp e2;
RT.T_If (extend_env_l f sg) (elab_exp b) (elab_exp e1) (elab_exp e2) _ _ hyp _ _ db d1 d2 t_ok
| T_App _ e1 e2 t t' t0 d1 d2 st ->
let dt1:RT.tot_typing (extend_env_l f sg) (elab_exp e1) (elab_ty (TArrow t t')) = soundness d1 in
let dt2:RT.tot_typing (extend_env_l f sg) (elab_exp e2) (elab_ty t0) = soundness d2 in
let st:RT.sub_typing (extend_env_l f sg) (elab_ty t0) (elab_ty t) = subtyping_soundness st in
let dt2:RT.tot_typing (extend_env_l f sg) (elab_exp e2) (elab_ty t) =
RT.T_Sub _ _ _ _ dt2 (RT.Relc_typ _ _ _ _ _ st)
in
RT.T_App _ _ _ _ (elab_ty t') _ dt1 dt2 | false |
DependentBoolRefinement.fst | DependentBoolRefinement.src_ty_ok_soundness | val src_ty_ok_soundness
(#f: fstar_top_env)
(sg: src_env{src_env_ok sg})
(t: src_ty)
(dt: src_ty_ok f sg t)
: GTot (RT.tot_typing (extend_env_l f sg) (elab_ty t) (RT.tm_type RT.u_zero))
(decreases (t_height dt)) | val src_ty_ok_soundness
(#f: fstar_top_env)
(sg: src_env{src_env_ok sg})
(t: src_ty)
(dt: src_ty_ok f sg t)
: GTot (RT.tot_typing (extend_env_l f sg) (elab_ty t) (RT.tm_type RT.u_zero))
(decreases (t_height dt)) | let rec soundness (#f:fstar_top_env)
(#sg:src_env { src_env_ok sg } )
(#se:src_exp)
(#st:src_ty)
(dd:src_typing f sg se st)
: GTot (RT.tot_typing (extend_env_l f sg)
(elab_exp se)
(elab_ty st))
(decreases (height dd))
= match dd with
| T_Bool _ true ->
RT.T_Const _ _ _ RT.CT_True
| T_Bool _ false ->
RT.T_Const _ _ _ RT.CT_False
| T_Var _ x ->
RT.T_Var _ (R.pack_namedv (RT.make_namedv x))
| T_Lam _ t e t' x dt de ->
let de : RT.tot_typing (extend_env_l f ((x,Inl t)::sg))
(elab_exp (open_exp e x))
(elab_ty t')
= soundness de
in
let de : RT.tot_typing (RT.extend_env (extend_env_l f sg) x (elab_ty t))
(elab_exp (open_exp e x))
(elab_ty t')
= de
in
fresh_is_fresh sg;
freevars_elab_exp e;
let dt : RT.tot_typing (extend_env_l f sg) (elab_ty t) (RT.tm_type RT.u_zero) =
src_ty_ok_soundness sg t dt
in
let dd
: RT.tot_typing (extend_env_l f sg)
(R.pack_ln (R.Tv_Abs (RT.mk_simple_binder RT.pp_name_default (elab_ty t)) (elab_exp e)))
(elab_ty (TArrow t (close_ty t' x)))
= RT.close_term_spec (elab_ty t') x;
assert (elab_ty (close_ty t' x) ==
RT.subst_term (elab_ty t') [ RT.ND x 0 ]);
RT.T_Abs (extend_env_l f sg)
x
(elab_ty t)
(elab_exp e)
(T.E_Total, elab_ty t')
_
_
_
_
dt
de
in
dd
| T_If _ b e1 e2 t1 t2 t hyp db d1 d2 s1 s2 tok ->
let db = soundness db in
let d1 = soundness d1 in
let d2 = soundness d2 in
let s1 = subtyping_soundness s1 in
let s2 = subtyping_soundness s2 in
let t_ok = src_ty_ok_soundness sg t tok in
let d1 = RT.T_Sub _ _ _ _ d1 (RT.Relc_typ _ _ _ _ _ s1) in
let d2 = RT.T_Sub _ _ _ _ d2 (RT.Relc_typ _ _ _ _ _ s2) in
freevars_elab_exp e1;
freevars_elab_exp e2;
RT.T_If (extend_env_l f sg) (elab_exp b) (elab_exp e1) (elab_exp e2) _ _ hyp _ _ db d1 d2 t_ok
| T_App _ e1 e2 t t' t0 d1 d2 st ->
let dt1
: RT.tot_typing (extend_env_l f sg)
(elab_exp e1)
(elab_ty (TArrow t t'))
= soundness d1
in
let dt2
: RT.tot_typing (extend_env_l f sg)
(elab_exp e2)
(elab_ty t0)
= soundness d2
in
let st
: RT.sub_typing (extend_env_l f sg) (elab_ty t0) (elab_ty t)
= subtyping_soundness st
in
let dt2
: RT.tot_typing (extend_env_l f sg)
(elab_exp e2)
(elab_ty t)
= RT.T_Sub _ _ _ _ dt2 (RT.Relc_typ _ _ _ _ _ st)
in
RT.T_App _ _ _ _ (elab_ty t') _ dt1 dt2
and src_ty_ok_soundness (#f:fstar_top_env)
(sg:src_env { src_env_ok sg })
(t:src_ty)
(dt:src_ty_ok f sg t)
: GTot (RT.tot_typing (extend_env_l f sg) (elab_ty t) (RT.tm_type RT.u_zero))
(decreases (t_height dt))
= match dt with
| OK_TBool _ ->
RT.T_FVar _ RT.bool_fv
| OK_TArrow _ t1 t2 x ok_t1 ok_t2 ->
let t1_ok = src_ty_ok_soundness sg _ ok_t1 in
let t2_ok = src_ty_ok_soundness ((x, Inl t1)::sg) _ ok_t2 in
freevars_elab_ty t2;
let arr_max = RT.T_Arrow _ x (elab_ty t1) (elab_ty t2) _ _ RT.pp_name_default R.Q_Explicit T.E_Total _ _ t1_ok t2_ok in
RT.simplify_umax arr_max
| OK_TRefine _ e x de ->
let de
: RT.tot_typing (RT.extend_env (extend_env_l f sg) x RT.bool_ty)
(elab_exp (open_exp e x))
(elab_ty TBool)
= soundness de
in
let de
: RT.tot_typing (RT.extend_env (extend_env_l f sg) x RT.bool_ty)
(r_b2t (elab_exp (open_exp e x)))
(RT.tm_type RT.u_zero)
= b2t_typing _ _ de
in
let bool_typing
: RT.tot_typing (extend_env_l f sg) RT.bool_ty (RT.tm_type RT.u_zero)
= RT.T_FVar _ RT.bool_fv
in
elab_open_b2t e x;
freevars_elab_exp e;
RT.T_Refine (extend_env_l f sg)
x
RT.bool_ty
(r_b2t (elab_exp e))
_ _ _ _
bool_typing
de | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 19,
"end_line": 846,
"start_col": 0,
"start_line": 710
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1
let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1
let check_sub_typing f
(sg:src_env)
(t0 t1:src_ty)
: T.Tac (sub_typing f sg t0 t1)
= if t0 = t1 then S_Refl _ t0
else T.fail "Not subtypes"
let weaken (f:fstar_top_env) (sg:src_env) (hyp:var { None? (lookup sg hyp) } ) (b:src_exp) (t0 t1:src_ty)
: T.Tac (t:src_ty &
sub_typing f ((hyp,Inr(b, EBool true))::sg) t0 t &
sub_typing f ((hyp,Inr(b, EBool false))::sg) t1 t)
= if t0 = t1
then (| t0, S_Refl _ t0, S_Refl _ t1 |)
else T.fail "weaken is very dumb"
let ok (sg:src_env) (e:src_exp) = (forall x. x `Set.mem` freevars e ==> Some? (lookup sg x))
let ok_ty (sg:src_env) (e:src_ty) = (forall x. x `Set.mem` freevars_ty e ==> Some? (lookup sg x))
let rec check_ok_ty (t:src_ty) (sg:src_env)
: b:bool { b <==> (ok_ty sg t) }
= match t with
| TBool -> true
| TArrow t1 t2 ->
check_ok_ty t1 sg &&
check_ok_ty t2 sg
| TRefineBool e ->
check_ok e sg
and check_ok (e:src_exp) (sg:src_env)
: b:bool { b <==> ok sg e }
= match e with
| EBVar _ -> true
| EVar x -> Some? (lookup sg x)
| EBool _ -> true
| EIf b e1 e2 -> check_ok b sg && check_ok e1 sg && check_ok e2 sg
| ELam t e -> check_ok_ty t sg && check_ok e sg
| EApp e1 e2 -> check_ok e1 sg && check_ok e2 sg
#push-options "--fuel 2 --ifuel 2 --z3rlimit_factor 6 --query_stats"
let rec check (f:fstar_top_env)
(sg:src_env)
(e:src_exp { ok sg e })
: T.Tac (t:src_ty &
src_typing f sg e t)
= match e with
| EBVar _ ->
T.fail "Not locally nameless"
| EBool b ->
(| TBool, T_Bool _ b |)
| EVar n ->
begin
match lookup_ty sg n with
| None -> T.fail "Ill-typed"
| Some t ->
let d = T_Var sg n in
(| t, d |)
end
| ELam t body ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars body (EVar x) 0;
let (| tbody, dbody |) = check f ((x, Inl t)::sg) (open_exp body x) in
let dd : src_typing f sg e (TArrow t (close_ty tbody x)) =
T_Lam sg t body tbody x t_ok dbody in
(| TArrow t (close_ty tbody x), dd |)
| EApp e1 e2 ->
let (| t1, d1 |) = check f sg e1 in
let (| t2, d2 |) = check f sg e2 in
begin
match t1 with
| TArrow t_arg t_res ->
let st_ok = check_sub_typing f sg t2 t_arg in
(| open_ty_with t_res e2, T_App _ _ _ t_arg t_res _ d1 d2 st_ok |)
| _ ->
T.fail "Expected a function"
end
| EIf b e1 e2 ->
let (| tb, ok_b |) = check f sg b in
let hyp = fresh sg in
fresh_is_fresh sg;
if tb = TBool
then (
let (| t1, ok_1 |) = check f ((hyp, Inr(b, EBool true))::sg) e1 in
let (| t2, ok_2 |) = check f ((hyp, Inr(b, EBool false))::sg) e2 in
let (| t, w1, w2 |) = weaken f sg hyp b t1 t2 in
if not (check_ok_ty t sg)
then T.fail "Free variable escapes scope"
else (
let t_ok = check_ty f sg t in
(| t, T_If _ _ _ _ _ _ _ hyp ok_b ok_1 ok_2 w1 w2 t_ok |)
)
)
else T.fail "Branching on a non-boolean"
and check_ty (f:fstar_top_env)
(sg:src_env)
(t:src_ty { ok_ty sg t })
: T.Tac (src_ty_ok f sg t)
= match t with
| TBool -> OK_TBool _
| TArrow t t' ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_ty_freevars t' (EVar x) 0;
let t'_ok = check_ty f ((x, Inl t)::sg) (open_ty t' x) in
OK_TArrow _ _ _ x t_ok t'_ok
| TRefineBool e ->
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars e (EVar x) 0;
let (| te, de |) = check f ((x, Inl TBool)::sg) (open_exp e x) in
match te with
| TBool -> OK_TRefine sg e x de
| _ -> T.fail "Ill-typed refinement"
#pop-options
let rec extend_env_l_lookup_bvar (g:R.env) (sg:src_env) (x:var)
: Lemma
(requires (forall x. RT.lookup_bvar g x == None))
(ensures (
match lookup sg x with
| Some b -> RT.lookup_bvar (extend_env_l g sg) x == Some (elab_binding b)
| None -> RT.lookup_bvar (extend_env_l g sg) x == None))
(decreases sg)
[SMTPat (RT.lookup_bvar (extend_env_l g sg) x)]
= match sg with
| [] -> ()
| hd :: tl -> extend_env_l_lookup_bvar g tl x
#push-options "--query_stats --fuel 8 --ifuel 2 --z3rlimit_factor 2"
let rec elab_open_commute' (n:nat) (e:src_exp) (x:src_exp)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.DT n (elab_exp x) ] ==
elab_exp (open_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| EIf b e1 e2 ->
elab_open_commute' n b x;
elab_open_commute' n e1 x;
elab_open_commute' n e2 x
| ELam t e ->
elab_ty_open_commute' n t x;
elab_open_commute' (n + 1) e x
and elab_ty_open_commute' (n:nat) (e:src_ty) (x:src_exp)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.DT n (elab_exp x) ] ==
elab_ty (open_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_open_commute' n t x;
elab_ty_open_commute' (n + 1) t' x
| TRefineBool e ->
elab_open_commute' (n + 1) e x
#pop-options
let elab_open_commute (e:src_exp) (x:var)
: Lemma (RT.open_term (elab_exp e) x == elab_exp (open_exp e x))
[SMTPat (RT.open_term (elab_exp e) x)]
= elab_open_commute' 0 e (EVar x);
RT.open_term_spec (elab_exp e) x
let b2t_typing (g:fstar_env) (t:R.term) (dt:RT.tot_typing g t RT.bool_ty)
: RT.tot_typing g (r_b2t t) (RT.tm_type RT.u_zero)
= let b2t_typing : RT.tot_typing g _ b2t_ty = RT.T_FVar g b2t_fv in
let app_ty : _ = RT.T_App _ _ _ _ (RT.tm_type RT.u_zero) _ b2t_typing dt in
RT.open_with_spec (RT.tm_type RT.u_zero) t;
app_ty
let rec extend_env_l_lookup_fvar (g:R.env) (sg:src_env) (fv:R.fv)
: Lemma
(ensures
RT.lookup_fvar (extend_env_l g sg) fv ==
RT.lookup_fvar g fv)
[SMTPat (RT.lookup_fvar (extend_env_l g sg) fv)]
= match sg with
| [] -> ()
| hd::tl -> extend_env_l_lookup_fvar g tl fv
#push-options "--query_stats --fuel 2 --ifuel 2 --z3rlimit_factor 2"
let subtyping_soundness #f (#sg:src_env) (#t0 #t1:src_ty) (ds:sub_typing f sg t0 t1)
: GTot (RT.sub_typing (extend_env_l f sg) (elab_ty t0) (elab_ty t1))
= match ds with
| S_Refl _ _ -> RT.Rel_equiv _ _ _ _ (RT.Rel_refl _ _ _)
| S_ELab _ _ _ d -> d
#push-options "--query_stats --fuel 8 --ifuel 2 --z3rlimit_factor 4"
let rec elab_close_commute' (n:nat) (e:src_exp) (x:var)
: Lemma (ensures
RT.subst_term (elab_exp e) [ RT.ND x n ] ==
elab_exp (close_exp' e x n))
(decreases e)
= match e with
| EBool _ -> ()
| EBVar _ -> ()
| EVar _ -> ()
| EApp e1 e2 ->
elab_close_commute' n e1 x;
elab_close_commute' n e2 x
| EIf b e1 e2 ->
elab_close_commute' n b x;
elab_close_commute' n e1 x;
elab_close_commute' n e2 x
| ELam t e ->
elab_ty_close_commute' n t x;
elab_close_commute' (n + 1) e x
and elab_ty_close_commute' (n:nat) (e:src_ty) (x:var)
: Lemma
(ensures
RT.subst_term (elab_ty e) [ RT.ND x n ] ==
elab_ty (close_ty' e x n))
(decreases e)
= match e with
| TBool -> ()
| TArrow t t' ->
elab_ty_close_commute' n t x;
elab_ty_close_commute' (n + 1) t' x
| TRefineBool e ->
elab_close_commute' (n + 1) e x
#pop-options
let elab_ty_close_commute (e:src_ty) (x:var)
: Lemma (RT.close_term (elab_ty e) x == elab_ty (close_ty e x))
[SMTPat (RT.close_term (elab_ty e) x)]
= RT.close_term_spec (elab_ty e) x;
elab_ty_close_commute' 0 e x
let elab_ty_open_with_commute (e:src_ty) (v:src_exp)
: Lemma (RT.open_with (elab_ty e) (elab_exp v) == elab_ty (open_ty_with e v))
[SMTPat (RT.open_with (elab_ty e) (elab_exp v))]
= elab_ty_open_commute' 0 e v;
RT.open_with_spec (elab_ty e) (elab_exp v)
let elab_ty_open_commute (e:src_ty) (v:var)
: Lemma (RT.open_term (elab_ty e) v == elab_ty (open_ty e v))
[SMTPat (RT.open_term (elab_ty e) v)]
= elab_ty_open_commute' 0 e (EVar v);
RT.open_term_spec (elab_ty e) v
let elab_open_b2t (e:src_exp) (x:var)
: Lemma (RT.open_term (r_b2t (elab_exp e)) x ==
r_b2t (elab_exp (open_exp e x)))
= RT.open_term_spec (r_b2t (elab_exp e)) x;
RT.open_term_spec (elab_exp e) x | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 2,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 2,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
sg: DependentBoolRefinement.src_env{DependentBoolRefinement.src_env_ok sg} ->
t: DependentBoolRefinement.src_ty ->
dt: DependentBoolRefinement.src_ty_ok f sg t
-> Prims.GTot
(FStar.Reflection.Typing.tot_typing (DependentBoolRefinement.extend_env_l f sg)
(DependentBoolRefinement.elab_ty t)
(FStar.Reflection.Typing.tm_type FStar.Reflection.Typing.u_zero)) | Prims.GTot | [
"sometrivial",
""
] | [
"soundness",
"src_ty_ok_soundness"
] | [
"DependentBoolRefinement.fstar_top_env",
"DependentBoolRefinement.src_env",
"Prims.b2t",
"DependentBoolRefinement.src_env_ok",
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.src_ty_ok",
"FStar.Reflection.Typing.T_FVar",
"DependentBoolRefinement.extend_env_l",
"FStar.Reflection.Typing.bool_fv",
"DependentBoolRefinement.var",
"Prims.l_and",
"FStar.Pervasives.Native.uu___is_None",
"DependentBoolRefinement.binding",
"DependentBoolRefinement.lookup",
"Prims.l_not",
"FStar.Set.mem",
"DependentBoolRefinement.freevars_ty",
"Prims.Cons",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Inl",
"DependentBoolRefinement.src_eqn",
"DependentBoolRefinement.open_ty",
"FStar.Reflection.Typing.simplify_umax",
"FStar.Stubs.Reflection.V2.Builtins.pack_ln",
"FStar.Stubs.Reflection.V2.Data.Tv_Arrow",
"FStar.Reflection.Typing.mk_binder",
"FStar.Reflection.Typing.pp_name_default",
"DependentBoolRefinement.elab_ty",
"FStar.Stubs.Reflection.V2.Data.Q_Explicit",
"FStar.Reflection.Typing.mk_comp",
"FStar.Stubs.TypeChecker.Core.tot_or_ghost",
"FStar.Stubs.Reflection.Types.typ",
"FStar.Stubs.TypeChecker.Core.E_Total",
"FStar.Reflection.Typing.u_zero",
"FStar.Reflection.Typing.typing",
"FStar.Reflection.Typing.tm_type",
"FStar.Reflection.Typing.u_max",
"FStar.Reflection.Typing.T_Arrow",
"Prims.unit",
"DependentBoolRefinement.freevars_elab_ty",
"FStar.Reflection.Typing.tot_typing",
"DependentBoolRefinement.src_ty_ok_soundness",
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.freevars",
"DependentBoolRefinement.src_typing",
"DependentBoolRefinement.TBool",
"DependentBoolRefinement.open_exp",
"FStar.Reflection.Typing.T_Refine",
"FStar.Reflection.Typing.bool_ty",
"DependentBoolRefinement.r_b2t",
"DependentBoolRefinement.elab_exp",
"DependentBoolRefinement.freevars_elab_exp",
"DependentBoolRefinement.elab_open_b2t",
"FStar.Reflection.Typing.extend_env",
"DependentBoolRefinement.b2t_typing",
"DependentBoolRefinement.soundness"
] | [
"mutual recursion"
] | false | false | false | false | false | let rec src_ty_ok_soundness
(#f: fstar_top_env)
(sg: src_env{src_env_ok sg})
(t: src_ty)
(dt: src_ty_ok f sg t)
: GTot (RT.tot_typing (extend_env_l f sg) (elab_ty t) (RT.tm_type RT.u_zero))
(decreases (t_height dt)) =
| match dt with
| OK_TBool _ -> RT.T_FVar _ RT.bool_fv
| OK_TArrow _ t1 t2 x ok_t1 ok_t2 ->
let t1_ok = src_ty_ok_soundness sg _ ok_t1 in
let t2_ok = src_ty_ok_soundness ((x, Inl t1) :: sg) _ ok_t2 in
freevars_elab_ty t2;
let arr_max =
RT.T_Arrow _
x
(elab_ty t1)
(elab_ty t2)
_
_
RT.pp_name_default
R.Q_Explicit
T.E_Total
_
_
t1_ok
t2_ok
in
RT.simplify_umax arr_max
| OK_TRefine _ e x de ->
let de:RT.tot_typing (RT.extend_env (extend_env_l f sg) x RT.bool_ty)
(elab_exp (open_exp e x))
(elab_ty TBool) =
soundness de
in
let de:RT.tot_typing (RT.extend_env (extend_env_l f sg) x RT.bool_ty)
(r_b2t (elab_exp (open_exp e x)))
(RT.tm_type RT.u_zero) =
b2t_typing _ _ de
in
let bool_typing:RT.tot_typing (extend_env_l f sg) RT.bool_ty (RT.tm_type RT.u_zero) =
RT.T_FVar _ RT.bool_fv
in
elab_open_b2t e x;
freevars_elab_exp e;
RT.T_Refine (extend_env_l f sg) x RT.bool_ty (r_b2t (elab_exp e)) _ _ _ _ bool_typing de | false |
DependentBoolRefinement.fst | DependentBoolRefinement.check | val check (f: fstar_top_env) (sg: src_env) (e: src_exp{ok sg e})
: T.Tac (t: src_ty & src_typing f sg e t) | val check (f: fstar_top_env) (sg: src_env) (e: src_exp{ok sg e})
: T.Tac (t: src_ty & src_typing f sg e t) | let rec check (f:fstar_top_env)
(sg:src_env)
(e:src_exp { ok sg e })
: T.Tac (t:src_ty &
src_typing f sg e t)
= match e with
| EBVar _ ->
T.fail "Not locally nameless"
| EBool b ->
(| TBool, T_Bool _ b |)
| EVar n ->
begin
match lookup_ty sg n with
| None -> T.fail "Ill-typed"
| Some t ->
let d = T_Var sg n in
(| t, d |)
end
| ELam t body ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars body (EVar x) 0;
let (| tbody, dbody |) = check f ((x, Inl t)::sg) (open_exp body x) in
let dd : src_typing f sg e (TArrow t (close_ty tbody x)) =
T_Lam sg t body tbody x t_ok dbody in
(| TArrow t (close_ty tbody x), dd |)
| EApp e1 e2 ->
let (| t1, d1 |) = check f sg e1 in
let (| t2, d2 |) = check f sg e2 in
begin
match t1 with
| TArrow t_arg t_res ->
let st_ok = check_sub_typing f sg t2 t_arg in
(| open_ty_with t_res e2, T_App _ _ _ t_arg t_res _ d1 d2 st_ok |)
| _ ->
T.fail "Expected a function"
end
| EIf b e1 e2 ->
let (| tb, ok_b |) = check f sg b in
let hyp = fresh sg in
fresh_is_fresh sg;
if tb = TBool
then (
let (| t1, ok_1 |) = check f ((hyp, Inr(b, EBool true))::sg) e1 in
let (| t2, ok_2 |) = check f ((hyp, Inr(b, EBool false))::sg) e2 in
let (| t, w1, w2 |) = weaken f sg hyp b t1 t2 in
if not (check_ok_ty t sg)
then T.fail "Free variable escapes scope"
else (
let t_ok = check_ty f sg t in
(| t, T_If _ _ _ _ _ _ _ hyp ok_b ok_1 ok_2 w1 w2 t_ok |)
)
)
else T.fail "Branching on a non-boolean"
and check_ty (f:fstar_top_env)
(sg:src_env)
(t:src_ty { ok_ty sg t })
: T.Tac (src_ty_ok f sg t)
= match t with
| TBool -> OK_TBool _
| TArrow t t' ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_ty_freevars t' (EVar x) 0;
let t'_ok = check_ty f ((x, Inl t)::sg) (open_ty t' x) in
OK_TArrow _ _ _ x t_ok t'_ok
| TRefineBool e ->
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars e (EVar x) 0;
let (| te, de |) = check f ((x, Inl TBool)::sg) (open_exp e x) in
match te with
| TBool -> OK_TRefine sg e x de
| _ -> T.fail "Ill-typed refinement" | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 42,
"end_line": 565,
"start_col": 0,
"start_line": 477
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1
let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1
let check_sub_typing f
(sg:src_env)
(t0 t1:src_ty)
: T.Tac (sub_typing f sg t0 t1)
= if t0 = t1 then S_Refl _ t0
else T.fail "Not subtypes"
let weaken (f:fstar_top_env) (sg:src_env) (hyp:var { None? (lookup sg hyp) } ) (b:src_exp) (t0 t1:src_ty)
: T.Tac (t:src_ty &
sub_typing f ((hyp,Inr(b, EBool true))::sg) t0 t &
sub_typing f ((hyp,Inr(b, EBool false))::sg) t1 t)
= if t0 = t1
then (| t0, S_Refl _ t0, S_Refl _ t1 |)
else T.fail "weaken is very dumb"
let ok (sg:src_env) (e:src_exp) = (forall x. x `Set.mem` freevars e ==> Some? (lookup sg x))
let ok_ty (sg:src_env) (e:src_ty) = (forall x. x `Set.mem` freevars_ty e ==> Some? (lookup sg x))
let rec check_ok_ty (t:src_ty) (sg:src_env)
: b:bool { b <==> (ok_ty sg t) }
= match t with
| TBool -> true
| TArrow t1 t2 ->
check_ok_ty t1 sg &&
check_ok_ty t2 sg
| TRefineBool e ->
check_ok e sg
and check_ok (e:src_exp) (sg:src_env)
: b:bool { b <==> ok sg e }
= match e with
| EBVar _ -> true
| EVar x -> Some? (lookup sg x)
| EBool _ -> true
| EIf b e1 e2 -> check_ok b sg && check_ok e1 sg && check_ok e2 sg
| ELam t e -> check_ok_ty t sg && check_ok e sg
| EApp e1 e2 -> check_ok e1 sg && check_ok e2 sg
#push-options "--fuel 2 --ifuel 2 --z3rlimit_factor 6 --query_stats" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 2,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 6,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
f: DependentBoolRefinement.fstar_top_env ->
sg: DependentBoolRefinement.src_env ->
e: DependentBoolRefinement.src_exp{DependentBoolRefinement.ok sg e}
-> FStar.Tactics.Effect.Tac
(Prims.dtuple2 DependentBoolRefinement.src_ty
(fun t -> DependentBoolRefinement.src_typing f sg e t)) | FStar.Tactics.Effect.Tac | [] | [
"check",
"check_ty"
] | [
"DependentBoolRefinement.fstar_top_env",
"DependentBoolRefinement.src_env",
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.ok",
"DependentBoolRefinement.index",
"FStar.Tactics.V2.Derived.fail",
"Prims.dtuple2",
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.src_typing",
"Prims.bool",
"Prims.Mkdtuple2",
"DependentBoolRefinement.TBool",
"DependentBoolRefinement.T_Bool",
"DependentBoolRefinement.var",
"DependentBoolRefinement.lookup_ty",
"DependentBoolRefinement.EVar",
"FStar.Pervasives.Native.__proj__Some__item__v",
"DependentBoolRefinement.T_Var",
"Prims.Cons",
"FStar.Pervasives.Native.tuple2",
"DependentBoolRefinement.binding",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Inl",
"DependentBoolRefinement.src_eqn",
"DependentBoolRefinement.open_exp",
"DependentBoolRefinement.TArrow",
"DependentBoolRefinement.close_ty",
"DependentBoolRefinement.T_Lam",
"DependentBoolRefinement.check",
"Prims.unit",
"DependentBoolRefinement.open_exp_freevars",
"DependentBoolRefinement.fresh_is_fresh",
"DependentBoolRefinement.fresh",
"DependentBoolRefinement.src_ty_ok",
"DependentBoolRefinement.check_ty",
"DependentBoolRefinement.open_ty_with",
"DependentBoolRefinement.T_App",
"DependentBoolRefinement.sub_typing",
"DependentBoolRefinement.check_sub_typing",
"Prims.op_Equality",
"FStar.Pervasives.Inr",
"DependentBoolRefinement.EBool",
"Prims.op_Negation",
"DependentBoolRefinement.check_ok_ty",
"DependentBoolRefinement.T_If",
"FStar.Pervasives.dtuple3",
"DependentBoolRefinement.weaken"
] | [
"mutual recursion"
] | false | true | false | false | false | let rec check (f: fstar_top_env) (sg: src_env) (e: src_exp{ok sg e})
: T.Tac (t: src_ty & src_typing f sg e t) =
| match e with
| EBVar _ -> T.fail "Not locally nameless"
| EBool b -> (| TBool, T_Bool _ b |)
| EVar n ->
(match lookup_ty sg n with
| None -> T.fail "Ill-typed"
| Some t ->
let d = T_Var sg n in
(| t, d |))
| ELam t body ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars body (EVar x) 0;
let (| tbody , dbody |) = check f ((x, Inl t) :: sg) (open_exp body x) in
let dd:src_typing f sg e (TArrow t (close_ty tbody x)) = T_Lam sg t body tbody x t_ok dbody in
(| TArrow t (close_ty tbody x), dd |)
| EApp e1 e2 ->
let (| t1 , d1 |) = check f sg e1 in
let (| t2 , d2 |) = check f sg e2 in
(match t1 with
| TArrow t_arg t_res ->
let st_ok = check_sub_typing f sg t2 t_arg in
(| open_ty_with t_res e2, T_App _ _ _ t_arg t_res _ d1 d2 st_ok |)
| _ -> T.fail "Expected a function")
| EIf b e1 e2 ->
let (| tb , ok_b |) = check f sg b in
let hyp = fresh sg in
fresh_is_fresh sg;
if tb = TBool
then
(let (| t1 , ok_1 |) = check f ((hyp, Inr (b, EBool true)) :: sg) e1 in
let (| t2 , ok_2 |) = check f ((hyp, Inr (b, EBool false)) :: sg) e2 in
let (| t , w1 , w2 |) = weaken f sg hyp b t1 t2 in
if not (check_ok_ty t sg)
then T.fail "Free variable escapes scope"
else
(let t_ok = check_ty f sg t in
(| t, T_If _ _ _ _ _ _ _ hyp ok_b ok_1 ok_2 w1 w2 t_ok |)))
else T.fail "Branching on a non-boolean" | false |
DependentBoolRefinement.fst | DependentBoolRefinement.check_ty | val check_ty (f: fstar_top_env) (sg: src_env) (t: src_ty{ok_ty sg t}) : T.Tac (src_ty_ok f sg t) | val check_ty (f: fstar_top_env) (sg: src_env) (t: src_ty{ok_ty sg t}) : T.Tac (src_ty_ok f sg t) | let rec check (f:fstar_top_env)
(sg:src_env)
(e:src_exp { ok sg e })
: T.Tac (t:src_ty &
src_typing f sg e t)
= match e with
| EBVar _ ->
T.fail "Not locally nameless"
| EBool b ->
(| TBool, T_Bool _ b |)
| EVar n ->
begin
match lookup_ty sg n with
| None -> T.fail "Ill-typed"
| Some t ->
let d = T_Var sg n in
(| t, d |)
end
| ELam t body ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars body (EVar x) 0;
let (| tbody, dbody |) = check f ((x, Inl t)::sg) (open_exp body x) in
let dd : src_typing f sg e (TArrow t (close_ty tbody x)) =
T_Lam sg t body tbody x t_ok dbody in
(| TArrow t (close_ty tbody x), dd |)
| EApp e1 e2 ->
let (| t1, d1 |) = check f sg e1 in
let (| t2, d2 |) = check f sg e2 in
begin
match t1 with
| TArrow t_arg t_res ->
let st_ok = check_sub_typing f sg t2 t_arg in
(| open_ty_with t_res e2, T_App _ _ _ t_arg t_res _ d1 d2 st_ok |)
| _ ->
T.fail "Expected a function"
end
| EIf b e1 e2 ->
let (| tb, ok_b |) = check f sg b in
let hyp = fresh sg in
fresh_is_fresh sg;
if tb = TBool
then (
let (| t1, ok_1 |) = check f ((hyp, Inr(b, EBool true))::sg) e1 in
let (| t2, ok_2 |) = check f ((hyp, Inr(b, EBool false))::sg) e2 in
let (| t, w1, w2 |) = weaken f sg hyp b t1 t2 in
if not (check_ok_ty t sg)
then T.fail "Free variable escapes scope"
else (
let t_ok = check_ty f sg t in
(| t, T_If _ _ _ _ _ _ _ hyp ok_b ok_1 ok_2 w1 w2 t_ok |)
)
)
else T.fail "Branching on a non-boolean"
and check_ty (f:fstar_top_env)
(sg:src_env)
(t:src_ty { ok_ty sg t })
: T.Tac (src_ty_ok f sg t)
= match t with
| TBool -> OK_TBool _
| TArrow t t' ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_ty_freevars t' (EVar x) 0;
let t'_ok = check_ty f ((x, Inl t)::sg) (open_ty t' x) in
OK_TArrow _ _ _ x t_ok t'_ok
| TRefineBool e ->
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars e (EVar x) 0;
let (| te, de |) = check f ((x, Inl TBool)::sg) (open_exp e x) in
match te with
| TBool -> OK_TRefine sg e x de
| _ -> T.fail "Ill-typed refinement" | {
"file_name": "examples/dsls/dependent_bool_refinement/DependentBoolRefinement.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 42,
"end_line": 565,
"start_col": 0,
"start_line": 477
} | module DependentBoolRefinement
module T = FStar.Tactics.V2
module R = FStar.Reflection.V2
open FStar.List.Tot
module L = FStar.List.Tot
#push-options "--z3cliopt 'smt.qi.eager_threshold=100' --z3cliopt 'smt.arith.nl=false'"
let var = nat
let index = nat
let tun = R.pack_ln R.Tv_Unknown
type src_exp =
| EBVar : index -> src_exp
| EVar : var -> src_exp
| EBool : bool -> src_exp
| EIf : src_exp -> src_exp -> src_exp -> src_exp
| ELam : src_ty -> src_exp -> src_exp
| EApp : src_exp -> src_exp -> src_exp
and src_ty =
| TBool : src_ty
| TRefineBool : src_exp -> src_ty
| TArrow : src_ty -> src_ty -> src_ty
let rec freevars (e:src_exp)
: FStar.Set.set var
= match e with
| EVar v -> Set.singleton v
| EBool _
| EBVar _ -> Set.empty
| EIf b e1 e2 -> Set.union (freevars b) (Set.union (freevars e1) (freevars e2))
| ELam t e -> Set.union (freevars_ty t) (freevars e)
| EApp e1 e2 -> Set.union (freevars e1) (freevars e2)
and freevars_ty (t:src_ty)
: Set.set var
= match t with
| TBool -> Set.empty
| TArrow t1 t2 -> freevars_ty t1 `Set.union` freevars_ty t2
| TRefineBool e -> freevars e
let rec ln' (e:src_exp) (n:int)
: bool
= match e with
| EBool _
| EVar _ -> true
| EBVar m -> m <= n
| EIf b e1 e2 -> ln' b n && ln' e1 n && ln' e2 n
| ELam t e -> ln_ty' t n && ln' e (n + 1)
| EApp e1 e2 -> ln' e1 n && ln' e2 n
and ln_ty' (t:src_ty) (n:int)
: bool
= match t with
| TBool -> true
| TRefineBool e -> ln' e (n + 1)
| TArrow t1 t2 -> ln_ty' t1 n && ln_ty' t2 (n + 1) //Pi types
let ln e = ln' e (-1)
let ln_ty t = ln_ty' t (-1)
let rec open_exp' (e:src_exp) (v:src_exp) (n:index)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> EVar m
| EBVar m -> if m = n then v else EBVar m
| EIf b e1 e2 -> EIf (open_exp' b v n) (open_exp' e1 v n) (open_exp' e2 v n)
| ELam t e -> ELam (open_ty' t v n) (open_exp' e v (n + 1))
| EApp e1 e2 -> EApp (open_exp' e1 v n) (open_exp' e2 v n)
and open_ty' (t:src_ty) (v:src_exp) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (open_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (open_ty' t1 v n) (open_ty' t2 v (n + 1))
let rec close_exp' (e:src_exp) (v:var) (n:nat)
: Tot src_exp
(decreases e)
= match e with
| EBool _ -> e
| EVar m -> if m = v then EBVar n else EVar m
| EBVar m -> EBVar m
| EIf b e1 e2 -> EIf (close_exp' b v n) (close_exp' e1 v n) (close_exp' e2 v n)
| ELam t e -> ELam (close_ty' t v n) (close_exp' e v (n + 1))
| EApp e1 e2 -> EApp (close_exp' e1 v n) (close_exp' e2 v n)
and close_ty' (t:src_ty) (v:var) (n:index)
: Tot src_ty
(decreases t)
= match t with
| TBool -> TBool
| TRefineBool e -> TRefineBool (close_exp' e v (n + 1))
| TArrow t1 t2 -> TArrow (close_ty' t1 v n) (close_ty' t2 v (n + 1))
let open_exp e v = open_exp' e (EVar v) 0
let close_exp e v = close_exp' e v 0
let open_with e e' = open_exp' e e' 0
let open_ty t v = open_ty' t (EVar v) 0
let close_ty t v = close_ty' t v 0
let open_ty_with t e = open_ty' t e 0
#push-options "--query_stats --fuel 4 --ifuel 2 --z3rlimit_factor 8"
let rec open_exp_freevars (e:src_exp) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars e `Set.subset` freevars (open_exp' e v n)) /\
(freevars (open_exp' e v n) `Set.subset` (freevars e `Set.union` freevars v)))
(decreases e)
// [SMTPat (freevars (open_exp' e v n))]
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| EApp e1 e2 ->
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| EIf b e1 e2 ->
open_exp_freevars b v n;
open_exp_freevars e1 v n;
open_exp_freevars e2 v n
| ELam t e ->
open_ty_freevars t v n;
open_exp_freevars e v (n + 1)
and open_ty_freevars (t:src_ty) (v:src_exp) (n:nat)
: Lemma
(ensures (freevars_ty t `Set.subset` freevars_ty (open_ty' t v n)) /\
(freevars_ty (open_ty' t v n) `Set.subset` (freevars_ty t `Set.union` freevars v)))
(decreases t)
// [SMTPat (freevars_ty (open_ty' t v n))]
= match t with
| TBool -> ()
| TArrow t1 t2 ->
open_ty_freevars t1 v n;
open_ty_freevars t2 v (n + 1)
| TRefineBool e ->
open_exp_freevars e v (n + 1)
#pop-options
//environment binds types or equations
let src_eqn = src_exp & src_exp
let binding = either src_ty src_eqn
let src_env = list (var & binding)
let rec lookup (e:list (var & 'a)) (x:var)
: option 'a
= match e with
| [] -> None
| (y, v) :: tl -> if x = y then Some v else lookup tl x
let rec src_env_ok (s:src_env)
: bool
= match s with
| [] -> true
| (x, _)::tl -> None? (lookup tl x) && src_env_ok tl
let lookup_ty (e:src_env) (x:var)
: option src_ty
= match lookup e x with
| Some (Inl t) -> Some t
| _ -> None
let max (n1 n2:nat) = if n1 < n2 then n2 else n1
let rec fresh (e:list (var & 'a))
: var
= match e with
| [] -> 0
| (y, _) :: tl -> max (fresh tl) y + 1
| _ :: tl -> fresh tl
let rec fresh_not_mem (e:list (var & 'a)) (elt: (var & 'a))
: Lemma (ensures L.memP elt e ==> fresh e > fst elt)
= match e with
| [] -> ()
| hd :: tl -> fresh_not_mem tl elt
let rec lookup_mem (e:list (var & 'a)) (x:var)
: Lemma
(requires Some? (lookup e x))
(ensures exists elt. L.memP elt e /\ fst elt == x)
= match e with
| [] -> ()
| hd :: tl ->
match lookup tl x with
| None -> assert (L.memP hd e)
| _ ->
lookup_mem tl x;
eliminate exists elt. L.memP elt tl /\ fst elt == x
returns _
with _ . (
introduce exists elt. L.memP elt e /\ fst elt == x
with elt
and ()
)
let fresh_is_fresh (e:src_env)
: Lemma (None? (lookup e (fresh e)))
= match lookup e (fresh e) with
| None -> ()
| Some _ ->
lookup_mem e (fresh e);
FStar.Classical.forall_intro (fresh_not_mem e)
module RT = FStar.Reflection.Typing
let b2t_lid : R.name = ["Prims"; "b2t"]
let b2t_fv : R.fv = R.pack_fv b2t_lid
let b2t_ty : R.term = R.(pack_ln (Tv_Arrow (RT.mk_simple_binder RT.pp_name_default RT.bool_ty) (RT.mk_total (RT.tm_type RT.u_zero))))
let r_b2t (t:R.term)
: R.term
= R.(pack_ln (Tv_App (pack_ln (Tv_FVar b2t_fv)) (t, Q_Explicit)))
let rec elab_exp (e:src_exp)
: Tot R.term
= let open R in
match e with
| EBool true ->
pack_ln (Tv_Const R.C_True)
| EBool false ->
pack_ln (Tv_Const R.C_False)
| EBVar n ->
let bv = R.pack_bv (RT.make_bv n) in
R.pack_ln (Tv_BVar bv)
| EVar n ->
let v = R.pack_namedv (RT.make_namedv n) in
R.pack_ln (Tv_Var v)
| ELam t e ->
let t = elab_ty t in
let e = elab_exp e in
R.pack_ln (Tv_Abs (RT.mk_simple_binder RT.pp_name_default t) e)
| EApp e1 e2 ->
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_App e1 (e2, Q_Explicit))
| EIf b e1 e2 ->
let b = elab_exp b in
let e1 = elab_exp e1 in
let e2 = elab_exp e2 in
R.pack_ln (Tv_Match b None [(Pat_Constant C_True, e1); (Pat_Constant C_False, e2)])
and elab_ty (t:src_ty)
: R.term
= let open R in
match t with
| TBool ->
RT.bool_ty
| TArrow t1 t2 ->
let t1 = elab_ty t1 in
let t2 = elab_ty t2 in
R.pack_ln
(R.Tv_Arrow
(RT.mk_simple_binder RT.pp_name_default t1)
(RT.mk_total t2)) //(R.pack_comp (C_Total t2 [])))
| TRefineBool e ->
let e = elab_exp e in
let b = RT.mk_simple_binder RT.pp_name_default RT.bool_ty in
let bv = R.pack_bv (RT.make_bv 0) in
let refinement = r_b2t e in
R.pack_ln (Tv_Refine b refinement)
let rec freevars_elab_exp (e:src_exp)
: Lemma (freevars e `Set.equal` RT.freevars (elab_exp e))
= match e with
| EBool _
| EBVar _
| EVar _ -> ()
| ELam t e ->
freevars_elab_ty t;
freevars_elab_exp e
| EApp e1 e2 ->
freevars_elab_exp e1;
freevars_elab_exp e2
| EIf b e1 e2 ->
freevars_elab_exp b;
freevars_elab_exp e1;
freevars_elab_exp e2
and freevars_elab_ty (t:src_ty)
: Lemma (freevars_ty t `Set.equal` RT.freevars (elab_ty t))
= match t with
| TBool -> ()
| TArrow t1 t2 ->
freevars_elab_ty t1;
freevars_elab_ty t2
| TRefineBool e ->
freevars_elab_exp e
let elab_eqn (e1 e2:src_exp)
: R.term
= RT.eq2 RT.u_zero RT.bool_ty (elab_exp e1) (elab_exp e2)
let elab_binding (b:binding)
: R.term
= match b with
| Inl t -> elab_ty t
| Inr (e1, e2) -> elab_eqn e1 e2
let extend_env_l (g:R.env) (sg:src_env) =
L.fold_right
(fun (x, b) g -> RT.extend_env g x (elab_binding b))
sg
g
let fstar_env =
g:R.env {
RT.lookup_fvar g RT.bool_fv == Some (RT.tm_type RT.u_zero) /\
RT.lookup_fvar g b2t_fv == Some b2t_ty
}
let fstar_top_env =
g:fstar_env {
forall x. None? (RT.lookup_bvar g x )
}
[@@erasable]
noeq
type sub_typing (f:fstar_top_env) : src_env -> src_ty -> src_ty -> Type =
| S_Refl : g:src_env -> t:src_ty -> sub_typing f g t t
| S_ELab : g:src_env -> t0:src_ty -> t1:src_ty ->
RT.sub_typing (extend_env_l f g) (elab_ty t0) (elab_ty t1) ->
sub_typing f g t0 t1
[@@erasable]
noeq
type src_typing (f:fstar_top_env) : src_env -> src_exp -> src_ty -> Type =
| T_Bool :
g:src_env ->
b:bool ->
src_typing f g (EBool b) TBool
| T_Var :
g:src_env ->
x:var { Some? (lookup_ty g x) } ->
src_typing f g (EVar x) (Some?.v (lookup_ty g x))
| T_Lam :
g:src_env ->
t:src_ty ->
e:src_exp ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_ty_ok f g t ->
src_typing f ((x, Inl t) :: g) (open_exp e x) t' ->
src_typing f g (ELam t e) (TArrow t (close_ty t' x))
| T_App :
g:src_env ->
e1:src_exp ->
e2:src_exp ->
t:src_ty ->
t':src_ty ->
t0:src_ty ->
src_typing f g e1 (TArrow t t') ->
src_typing f g e2 t0 ->
sub_typing f g t0 t ->
src_typing f g (EApp e1 e2) (open_ty_with t' e2)
| T_If :
g:src_env ->
b:src_exp ->
e1:src_exp ->
e2:src_exp ->
t1:src_ty ->
t2:src_ty ->
t:src_ty ->
hyp:var { None? (lookup g hyp) /\ ~ (hyp `Set.mem` freevars e1) /\ ~ (hyp `Set.mem` freevars e2) } ->
src_typing f g b TBool ->
src_typing f ((hyp, Inr (b, EBool true)) :: g) e1 t1 ->
src_typing f ((hyp, Inr (b, EBool false)) :: g) e2 t2 ->
sub_typing f ((hyp, Inr (b, EBool true)) :: g) t1 t ->
sub_typing f ((hyp, Inr (b, EBool false)) :: g) t2 t ->
src_ty_ok f g t -> //hyp cannot escape
src_typing f g (EIf b e1 e2) t
and src_ty_ok (f:fstar_top_env) : src_env -> src_ty -> Type =
| OK_TBool : g:src_env -> src_ty_ok f g TBool
| OK_TArrow :
g:src_env ->
t:src_ty ->
t':src_ty ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars_ty t')} ->
src_ty_ok f g t ->
src_ty_ok f ((x,Inl t)::g) (open_ty t' x) ->
src_ty_ok f g (TArrow t t')
| OK_TRefine:
g:src_env ->
e:src_exp ->
x:var { None? (lookup g x) /\ ~ (x `Set.mem` freevars e)} ->
src_typing f ((x, Inl TBool)::g) (open_exp e x) TBool ->
src_ty_ok f g (TRefineBool e)
let s_height #f #g #t0 #t1 (d:sub_typing f g t0 t1)
: GTot nat
= 1
let rec height #f #g #e #t (d:src_typing f g e t)
: GTot nat (decreases d)
= match d with
| T_Bool _ _ -> 1
| T_Var _ _ -> 1
| T_Lam _ _ _ _ _ ty_ok body -> max (height body) (t_height ty_ok) + 1
| T_App _ _ _ _ _ _ tl tr ts -> max (max (height tl) (height tr)) (s_height ts) + 1
| T_If _ _ _ _ _ _ _ _ tb tl tr sl sr st ->
max (height tb)
(max (max (height tl) (height tr))
(max (s_height sl) (max (s_height sr) (t_height st)))) + 1
and t_height #f (#g:src_env) (#t:src_ty) (d:src_ty_ok f g t)
: GTot nat (decreases d)
= match d with
| OK_TBool _ -> 1
| OK_TArrow _ _ _ _ d0 d1 -> max (t_height d0) (t_height d1) + 1
| OK_TRefine _ _ _ d -> height d + 1
let check_sub_typing f
(sg:src_env)
(t0 t1:src_ty)
: T.Tac (sub_typing f sg t0 t1)
= if t0 = t1 then S_Refl _ t0
else T.fail "Not subtypes"
let weaken (f:fstar_top_env) (sg:src_env) (hyp:var { None? (lookup sg hyp) } ) (b:src_exp) (t0 t1:src_ty)
: T.Tac (t:src_ty &
sub_typing f ((hyp,Inr(b, EBool true))::sg) t0 t &
sub_typing f ((hyp,Inr(b, EBool false))::sg) t1 t)
= if t0 = t1
then (| t0, S_Refl _ t0, S_Refl _ t1 |)
else T.fail "weaken is very dumb"
let ok (sg:src_env) (e:src_exp) = (forall x. x `Set.mem` freevars e ==> Some? (lookup sg x))
let ok_ty (sg:src_env) (e:src_ty) = (forall x. x `Set.mem` freevars_ty e ==> Some? (lookup sg x))
let rec check_ok_ty (t:src_ty) (sg:src_env)
: b:bool { b <==> (ok_ty sg t) }
= match t with
| TBool -> true
| TArrow t1 t2 ->
check_ok_ty t1 sg &&
check_ok_ty t2 sg
| TRefineBool e ->
check_ok e sg
and check_ok (e:src_exp) (sg:src_env)
: b:bool { b <==> ok sg e }
= match e with
| EBVar _ -> true
| EVar x -> Some? (lookup sg x)
| EBool _ -> true
| EIf b e1 e2 -> check_ok b sg && check_ok e1 sg && check_ok e2 sg
| ELam t e -> check_ok_ty t sg && check_ok e sg
| EApp e1 e2 -> check_ok e1 sg && check_ok e2 sg
#push-options "--fuel 2 --ifuel 2 --z3rlimit_factor 6 --query_stats" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Reflection.V2.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "DependentBoolRefinement.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 2,
"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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=100",
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 6,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
f: DependentBoolRefinement.fstar_top_env ->
sg: DependentBoolRefinement.src_env ->
t: DependentBoolRefinement.src_ty{DependentBoolRefinement.ok_ty sg t}
-> FStar.Tactics.Effect.Tac (DependentBoolRefinement.src_ty_ok f sg t) | FStar.Tactics.Effect.Tac | [] | [
"check",
"check_ty"
] | [
"DependentBoolRefinement.fstar_top_env",
"DependentBoolRefinement.src_env",
"DependentBoolRefinement.src_ty",
"DependentBoolRefinement.ok_ty",
"DependentBoolRefinement.OK_TBool",
"DependentBoolRefinement.src_ty_ok",
"DependentBoolRefinement.OK_TArrow",
"Prims.Cons",
"FStar.Pervasives.Native.tuple2",
"DependentBoolRefinement.var",
"DependentBoolRefinement.binding",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Inl",
"DependentBoolRefinement.src_eqn",
"DependentBoolRefinement.open_ty",
"DependentBoolRefinement.check_ty",
"Prims.unit",
"DependentBoolRefinement.open_ty_freevars",
"DependentBoolRefinement.EVar",
"DependentBoolRefinement.fresh_is_fresh",
"DependentBoolRefinement.fresh",
"DependentBoolRefinement.src_exp",
"DependentBoolRefinement.src_typing",
"DependentBoolRefinement.TBool",
"DependentBoolRefinement.open_exp",
"DependentBoolRefinement.OK_TRefine",
"FStar.Tactics.V2.Derived.fail",
"Prims.dtuple2",
"DependentBoolRefinement.check",
"DependentBoolRefinement.open_exp_freevars"
] | [
"mutual recursion"
] | false | true | false | false | false | let rec check_ty (f: fstar_top_env) (sg: src_env) (t: src_ty{ok_ty sg t}) : T.Tac (src_ty_ok f sg t) =
| match t with
| TBool -> OK_TBool _
| TArrow t t' ->
let t_ok = check_ty f sg t in
let x = fresh sg in
fresh_is_fresh sg;
open_ty_freevars t' (EVar x) 0;
let t'_ok = check_ty f ((x, Inl t) :: sg) (open_ty t' x) in
OK_TArrow _ _ _ x t_ok t'_ok
| TRefineBool e ->
let x = fresh sg in
fresh_is_fresh sg;
open_exp_freevars e (EVar x) 0;
let (| te , de |) = check f ((x, Inl TBool) :: sg) (open_exp e x) in
match te with
| TBool -> OK_TRefine sg e x de
| _ -> T.fail "Ill-typed refinement" | false |
Benton2004.DDCC.Examples.fst | Benton2004.DDCC.Examples.d_op_singl | val d_op_singl
(#from #to: Type0)
(op: (from -> from -> Tot to))
(c1 c2: from)
(e1 e1' e2 e2': exp from)
(phi: sttype)
: Lemma (requires (eval_equiv phi (ns_singl c1) e1 e1' /\ eval_equiv phi (ns_singl c2) e2 e2'))
(ensures (eval_equiv phi (ns_singl (op c1 c2)) (eop op e1 e2) (eop op e1' e2')))
[SMTPat (eval_equiv phi (ns_singl (op c1 c2)) (eop op e1 e2) (eop op e1' e2'))] | val d_op_singl
(#from #to: Type0)
(op: (from -> from -> Tot to))
(c1 c2: from)
(e1 e1' e2 e2': exp from)
(phi: sttype)
: Lemma (requires (eval_equiv phi (ns_singl c1) e1 e1' /\ eval_equiv phi (ns_singl c2) e2 e2'))
(ensures (eval_equiv phi (ns_singl (op c1 c2)) (eop op e1 e2) (eop op e1' e2')))
[SMTPat (eval_equiv phi (ns_singl (op c1 c2)) (eop op e1 e2) (eop op e1' e2'))] | let d_op_singl
(#from #to: Type0)
(op: (from -> from -> Tot to))
(c1 c2: from)
(e1 e1' e2 e2': exp from)
(phi: sttype)
: Lemma
(requires (
eval_equiv phi (ns_singl c1) e1 e1' /\
eval_equiv phi (ns_singl c2) e2 e2'
))
(ensures (eval_equiv phi (ns_singl (op c1 c2)) (eop op e1 e2) (eop op e1' e2')))
[SMTPat (eval_equiv phi (ns_singl (op c1 c2)) (eop op e1 e2) (eop op e1' e2'))]
= op_abs_singl op c1 c2 ;
d_op op e1 e1' e2 e2' (ns_singl c1) (ns_singl c2) (ns_singl (op c1 c2)) phi | {
"file_name": "examples/rel/Benton2004.DDCC.Examples.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 77,
"end_line": 43,
"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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Benton2004.DDCC.Examples
open Benton2004.DDCC
#reset-options "--z3rlimit 128"
let op_abs_singl
(#from #to: Type0)
(op: (from -> from -> Tot to))
(c1 c2: from)
: Lemma
(op_abs op (ns_singl c1) (ns_singl c2) (ns_singl (op c1 c2)))
= () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"Benton2004.DDCC.fsti.checked"
],
"interface_file": false,
"source_file": "Benton2004.DDCC.Examples.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004.DDCC",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004.DDCC",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004.DDCC",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 128,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
op: (_: from -> _: from -> to) ->
c1: from ->
c2: from ->
e1: Benton2004.exp from ->
e1': Benton2004.exp from ->
e2: Benton2004.exp from ->
e2': Benton2004.exp from ->
phi: Benton2004.DDCC.sttype
-> FStar.Pervasives.Lemma
(requires
Benton2004.eval_equiv phi (Benton2004.DDCC.ns_singl c1) e1 e1' /\
Benton2004.eval_equiv phi (Benton2004.DDCC.ns_singl c2) e2 e2')
(ensures
Benton2004.eval_equiv phi
(Benton2004.DDCC.ns_singl (op c1 c2))
(Benton2004.eop op e1 e2)
(Benton2004.eop op e1' e2'))
[
SMTPat (Benton2004.eval_equiv phi
(Benton2004.DDCC.ns_singl (op c1 c2))
(Benton2004.eop op e1 e2)
(Benton2004.eop op e1' e2'))
] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.exp",
"Benton2004.DDCC.sttype",
"Benton2004.DDCC.d_op",
"Benton2004.DDCC.ns_singl",
"Prims.unit",
"Benton2004.DDCC.Examples.op_abs_singl",
"Prims.l_and",
"Benton2004.eval_equiv",
"Prims.squash",
"Benton2004.eop",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | true | false | true | false | false | let d_op_singl
(#from #to: Type0)
(op: (from -> from -> Tot to))
(c1 c2: from)
(e1 e1' e2 e2': exp from)
(phi: sttype)
: Lemma (requires (eval_equiv phi (ns_singl c1) e1 e1' /\ eval_equiv phi (ns_singl c2) e2 e2'))
(ensures (eval_equiv phi (ns_singl (op c1 c2)) (eop op e1 e2) (eop op e1' e2')))
[SMTPat (eval_equiv phi (ns_singl (op c1 c2)) (eop op e1 e2) (eop op e1' e2'))] =
| op_abs_singl op c1 c2;
d_op op e1 e1' e2 e2' (ns_singl c1) (ns_singl c2) (ns_singl (op c1 c2)) phi | false |
Benton2004.DDCC.Examples.fst | Benton2004.DDCC.Examples.fig3_d2 | val fig3_d2 (x: var) (phi: sttype) (z: var)
: Lemma (requires (x `st_fresh_in` phi /\ z `st_fresh_in` phi /\ x <> z))
(ensures
(x `st_fresh_in` phi /\ z `st_fresh_in` phi /\ x <> z /\
exec_equiv (st_cons (st_cons phi x (ns_singl 7)) z ns_t)
(st_cons (st_cons phi x ns_t) z (ns_singl 8))
(assign z (eop op_Addition (evar x) (const 1)))
(assign z (const 8)))) | val fig3_d2 (x: var) (phi: sttype) (z: var)
: Lemma (requires (x `st_fresh_in` phi /\ z `st_fresh_in` phi /\ x <> z))
(ensures
(x `st_fresh_in` phi /\ z `st_fresh_in` phi /\ x <> z /\
exec_equiv (st_cons (st_cons phi x (ns_singl 7)) z ns_t)
(st_cons (st_cons phi x ns_t) z (ns_singl 8))
(assign z (eop op_Addition (evar x) (const 1)))
(assign z (const 8)))) | let fig3_d2
(x: var)
(phi: sttype)
(z: var)
: Lemma
(requires (
x `st_fresh_in` phi /\
z `st_fresh_in` phi /\
x <> z
))
(ensures (
x `st_fresh_in` phi /\
z `st_fresh_in` phi /\
x <> z /\
exec_equiv
(st_cons (st_cons phi x (ns_singl 7)) z ns_t)
(st_cons (st_cons phi x ns_t) z (ns_singl 8))
(assign z (eop op_Addition (evar x) (const 1)))
(assign z (const 8))
))
= d_op_singl op_Addition 7 1 (evar x) (evar x) (const 1) (const 1) (st_cons phi x (ns_singl 7));
assert (
exec_equiv
(st_cons (st_cons phi x (ns_singl 7)) z ns_t)
(st_cons (st_cons phi x (ns_singl 7)) z (ns_singl 8))
(assign z (eop op_Addition (evar x) (const 1)))
(assign z (const 8))
) | {
"file_name": "examples/rel/Benton2004.DDCC.Examples.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 90,
"start_col": 0,
"start_line": 63
} | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Benton2004.DDCC.Examples
open Benton2004.DDCC
#reset-options "--z3rlimit 128"
let op_abs_singl
(#from #to: Type0)
(op: (from -> from -> Tot to))
(c1 c2: from)
: Lemma
(op_abs op (ns_singl c1) (ns_singl c2) (ns_singl (op c1 c2)))
= ()
let d_op_singl
(#from #to: Type0)
(op: (from -> from -> Tot to))
(c1 c2: from)
(e1 e1' e2 e2': exp from)
(phi: sttype)
: Lemma
(requires (
eval_equiv phi (ns_singl c1) e1 e1' /\
eval_equiv phi (ns_singl c2) e2 e2'
))
(ensures (eval_equiv phi (ns_singl (op c1 c2)) (eop op e1 e2) (eop op e1' e2')))
[SMTPat (eval_equiv phi (ns_singl (op c1 c2)) (eop op e1 e2) (eop op e1' e2'))]
= op_abs_singl op c1 c2 ;
d_op op e1 e1' e2 e2' (ns_singl c1) (ns_singl c2) (ns_singl (op c1 c2)) phi
let fig3_d1
(x: var)
(phi: sttype)
: Lemma
(requires (
x `st_fresh_in` phi
))
(ensures (
x `st_fresh_in` phi /\
exec_equiv
(st_cons phi x (ns_singl 3))
(st_cons phi x (ns_singl 7))
(ifthenelse (eop op_Equality (evar x) (const 3)) (assign x (const 7)) skip)
(assign x (const 7))
))
= d_op_singl (op_Equality #int) 3 3 (evar x) (evar x) (const 3) (const 3) (st_cons phi x (ns_singl 3))
// the rest is automatically inferred through patterns | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"Benton2004.DDCC.fsti.checked"
],
"interface_file": false,
"source_file": "Benton2004.DDCC.Examples.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004.DDCC",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004.DDCC",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004.DDCC",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 128,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | x: Benton2004.var -> phi: Benton2004.DDCC.sttype -> z: Benton2004.var
-> FStar.Pervasives.Lemma
(requires Benton2004.DDCC.st_fresh_in x phi /\ Benton2004.DDCC.st_fresh_in z phi /\ x <> z)
(ensures
Benton2004.DDCC.st_fresh_in x phi /\ Benton2004.DDCC.st_fresh_in z phi /\ x <> z /\
Benton2004.DDCC.exec_equiv (Benton2004.DDCC.st_cons (Benton2004.DDCC.st_cons phi
x
(Benton2004.DDCC.ns_singl 7))
z
Benton2004.DDCC.ns_t)
(Benton2004.DDCC.st_cons (Benton2004.DDCC.st_cons phi x Benton2004.DDCC.ns_t)
z
(Benton2004.DDCC.ns_singl 8))
(Benton2004.assign z
(Benton2004.eop Prims.op_Addition (Benton2004.evar x) (Benton2004.const 1)))
(Benton2004.assign z (Benton2004.const 8))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.var",
"Benton2004.DDCC.sttype",
"Prims._assert",
"Benton2004.DDCC.exec_equiv",
"Benton2004.DDCC.st_cons",
"Benton2004.DDCC.ns_singl",
"Prims.int",
"Benton2004.DDCC.ns_t",
"Benton2004.assign",
"Benton2004.eop",
"Prims.op_Addition",
"Benton2004.evar",
"Benton2004.const",
"Prims.unit",
"Benton2004.DDCC.Examples.d_op_singl",
"Prims.l_and",
"Benton2004.DDCC.st_fresh_in",
"Prims.b2t",
"Prims.op_disEquality",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let fig3_d2 (x: var) (phi: sttype) (z: var)
: Lemma (requires (x `st_fresh_in` phi /\ z `st_fresh_in` phi /\ x <> z))
(ensures
(x `st_fresh_in` phi /\ z `st_fresh_in` phi /\ x <> z /\
exec_equiv (st_cons (st_cons phi x (ns_singl 7)) z ns_t)
(st_cons (st_cons phi x ns_t) z (ns_singl 8))
(assign z (eop op_Addition (evar x) (const 1)))
(assign z (const 8)))) =
| d_op_singl op_Addition 7 1 (evar x) (evar x) (const 1) (const 1) (st_cons phi x (ns_singl 7));
assert (exec_equiv (st_cons (st_cons phi x (ns_singl 7)) z ns_t)
(st_cons (st_cons phi x (ns_singl 7)) z (ns_singl 8))
(assign z (eop op_Addition (evar x) (const 1)))
(assign z (const 8))) | false |
Benton2004.DDCC.Examples.fst | Benton2004.DDCC.Examples.fig3_d1 | val fig3_d1 (x: var) (phi: sttype)
: Lemma (requires (x `st_fresh_in` phi))
(ensures
(x `st_fresh_in` phi /\
exec_equiv (st_cons phi x (ns_singl 3))
(st_cons phi x (ns_singl 7))
(ifthenelse (eop op_Equality (evar x) (const 3)) (assign x (const 7)) skip)
(assign x (const 7)))) | val fig3_d1 (x: var) (phi: sttype)
: Lemma (requires (x `st_fresh_in` phi))
(ensures
(x `st_fresh_in` phi /\
exec_equiv (st_cons phi x (ns_singl 3))
(st_cons phi x (ns_singl 7))
(ifthenelse (eop op_Equality (evar x) (const 3)) (assign x (const 7)) skip)
(assign x (const 7)))) | let fig3_d1
(x: var)
(phi: sttype)
: Lemma
(requires (
x `st_fresh_in` phi
))
(ensures (
x `st_fresh_in` phi /\
exec_equiv
(st_cons phi x (ns_singl 3))
(st_cons phi x (ns_singl 7))
(ifthenelse (eop op_Equality (evar x) (const 3)) (assign x (const 7)) skip)
(assign x (const 7))
))
= d_op_singl (op_Equality #int) 3 3 (evar x) (evar x) (const 3) (const 3) (st_cons phi x (ns_singl 3)) | {
"file_name": "examples/rel/Benton2004.DDCC.Examples.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 102,
"end_line": 60,
"start_col": 0,
"start_line": 45
} | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Benton2004.DDCC.Examples
open Benton2004.DDCC
#reset-options "--z3rlimit 128"
let op_abs_singl
(#from #to: Type0)
(op: (from -> from -> Tot to))
(c1 c2: from)
: Lemma
(op_abs op (ns_singl c1) (ns_singl c2) (ns_singl (op c1 c2)))
= ()
let d_op_singl
(#from #to: Type0)
(op: (from -> from -> Tot to))
(c1 c2: from)
(e1 e1' e2 e2': exp from)
(phi: sttype)
: Lemma
(requires (
eval_equiv phi (ns_singl c1) e1 e1' /\
eval_equiv phi (ns_singl c2) e2 e2'
))
(ensures (eval_equiv phi (ns_singl (op c1 c2)) (eop op e1 e2) (eop op e1' e2')))
[SMTPat (eval_equiv phi (ns_singl (op c1 c2)) (eop op e1 e2) (eop op e1' e2'))]
= op_abs_singl op c1 c2 ;
d_op op e1 e1' e2 e2' (ns_singl c1) (ns_singl c2) (ns_singl (op c1 c2)) phi | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"Benton2004.DDCC.fsti.checked"
],
"interface_file": false,
"source_file": "Benton2004.DDCC.Examples.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004.DDCC",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004.DDCC",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004.DDCC",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 128,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | x: Benton2004.var -> phi: Benton2004.DDCC.sttype
-> FStar.Pervasives.Lemma (requires Benton2004.DDCC.st_fresh_in x phi)
(ensures
Benton2004.DDCC.st_fresh_in x phi /\
Benton2004.DDCC.exec_equiv (Benton2004.DDCC.st_cons phi x (Benton2004.DDCC.ns_singl 3))
(Benton2004.DDCC.st_cons phi x (Benton2004.DDCC.ns_singl 7))
(Benton2004.ifthenelse (Benton2004.eop Prims.op_Equality
(Benton2004.evar x)
(Benton2004.const 3))
(Benton2004.assign x (Benton2004.const 7))
Benton2004.skip)
(Benton2004.assign x (Benton2004.const 7))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.var",
"Benton2004.DDCC.sttype",
"Benton2004.DDCC.Examples.d_op_singl",
"Prims.int",
"Prims.bool",
"Prims.op_Equality",
"Benton2004.evar",
"Benton2004.const",
"Benton2004.DDCC.st_cons",
"Benton2004.DDCC.ns_singl",
"Prims.unit",
"Benton2004.DDCC.st_fresh_in",
"Prims.squash",
"Prims.l_and",
"Benton2004.DDCC.exec_equiv",
"Benton2004.ifthenelse",
"Benton2004.eop",
"Benton2004.assign",
"Benton2004.skip",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let fig3_d1 (x: var) (phi: sttype)
: Lemma (requires (x `st_fresh_in` phi))
(ensures
(x `st_fresh_in` phi /\
exec_equiv (st_cons phi x (ns_singl 3))
(st_cons phi x (ns_singl 7))
(ifthenelse (eop op_Equality (evar x) (const 3)) (assign x (const 7)) skip)
(assign x (const 7)))) =
| d_op_singl (op_Equality #int) 3 3 (evar x) (evar x) (const 3) (const 3) (st_cons phi x (ns_singl 3)) | false |
Benton2004.DDCC.Examples.fst | Benton2004.DDCC.Examples.fig3_d3 | val fig3_d3 (x: var) (phi: sttype) (z: var)
: Lemma (requires (x `st_fresh_in` phi /\ z `st_fresh_in` phi /\ x <> z))
(ensures
(x `st_fresh_in` phi /\ z `st_fresh_in` phi /\ x <> z /\
exec_equiv (st_cons (st_cons phi x (ns_singl 3)) z ns_t)
(st_cons (st_cons phi x ns_t) z (ns_singl 8))
(seq (assign x (const 7)) (assign z (const 8)))
(assign z (const 8)))) | val fig3_d3 (x: var) (phi: sttype) (z: var)
: Lemma (requires (x `st_fresh_in` phi /\ z `st_fresh_in` phi /\ x <> z))
(ensures
(x `st_fresh_in` phi /\ z `st_fresh_in` phi /\ x <> z /\
exec_equiv (st_cons (st_cons phi x (ns_singl 3)) z ns_t)
(st_cons (st_cons phi x ns_t) z (ns_singl 8))
(seq (assign x (const 7)) (assign z (const 8)))
(assign z (const 8)))) | let fig3_d3
(x: var)
(phi: sttype)
(z: var)
: Lemma
(requires (
x `st_fresh_in` phi /\
z `st_fresh_in` phi /\
x <> z
))
(ensures (
x `st_fresh_in` phi /\
z `st_fresh_in` phi /\
x <> z /\
exec_equiv
(st_cons (st_cons phi x (ns_singl 3)) z ns_t)
(st_cons (st_cons phi x ns_t) z (ns_singl 8))
(seq (assign x (const 7)) (assign z (const 8)))
(assign z (const 8))
))
= let c = assign x (const 7) in
let c' = assign z (const 8) in
let c'' = c' in
let phi_ = st_cons (st_cons phi x (ns_singl 3)) z ns_t in
let phi' = st_cons (st_cons phi x ns_t) z ns_t in
let phi'' = st_cons (st_cons phi x ns_t) z (ns_singl 8) in
d_das x (const 7) (st_cons phi z ns_t) (ns_singl 3);
d_assign (st_cons phi x ns_t) z ns_t (ns_singl 8) (const 8) (const 8);
d_su1' c c' c'' phi_ phi' phi'' | {
"file_name": "examples/rel/Benton2004.DDCC.Examples.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 33,
"end_line": 120,
"start_col": 0,
"start_line": 92
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Benton2004.DDCC.Examples
open Benton2004.DDCC
#reset-options "--z3rlimit 128"
let op_abs_singl
(#from #to: Type0)
(op: (from -> from -> Tot to))
(c1 c2: from)
: Lemma
(op_abs op (ns_singl c1) (ns_singl c2) (ns_singl (op c1 c2)))
= ()
let d_op_singl
(#from #to: Type0)
(op: (from -> from -> Tot to))
(c1 c2: from)
(e1 e1' e2 e2': exp from)
(phi: sttype)
: Lemma
(requires (
eval_equiv phi (ns_singl c1) e1 e1' /\
eval_equiv phi (ns_singl c2) e2 e2'
))
(ensures (eval_equiv phi (ns_singl (op c1 c2)) (eop op e1 e2) (eop op e1' e2')))
[SMTPat (eval_equiv phi (ns_singl (op c1 c2)) (eop op e1 e2) (eop op e1' e2'))]
= op_abs_singl op c1 c2 ;
d_op op e1 e1' e2 e2' (ns_singl c1) (ns_singl c2) (ns_singl (op c1 c2)) phi
let fig3_d1
(x: var)
(phi: sttype)
: Lemma
(requires (
x `st_fresh_in` phi
))
(ensures (
x `st_fresh_in` phi /\
exec_equiv
(st_cons phi x (ns_singl 3))
(st_cons phi x (ns_singl 7))
(ifthenelse (eop op_Equality (evar x) (const 3)) (assign x (const 7)) skip)
(assign x (const 7))
))
= d_op_singl (op_Equality #int) 3 3 (evar x) (evar x) (const 3) (const 3) (st_cons phi x (ns_singl 3))
// the rest is automatically inferred through patterns
let fig3_d2
(x: var)
(phi: sttype)
(z: var)
: Lemma
(requires (
x `st_fresh_in` phi /\
z `st_fresh_in` phi /\
x <> z
))
(ensures (
x `st_fresh_in` phi /\
z `st_fresh_in` phi /\
x <> z /\
exec_equiv
(st_cons (st_cons phi x (ns_singl 7)) z ns_t)
(st_cons (st_cons phi x ns_t) z (ns_singl 8))
(assign z (eop op_Addition (evar x) (const 1)))
(assign z (const 8))
))
= d_op_singl op_Addition 7 1 (evar x) (evar x) (const 1) (const 1) (st_cons phi x (ns_singl 7));
assert (
exec_equiv
(st_cons (st_cons phi x (ns_singl 7)) z ns_t)
(st_cons (st_cons phi x (ns_singl 7)) z (ns_singl 8))
(assign z (eop op_Addition (evar x) (const 1)))
(assign z (const 8))
) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"Benton2004.DDCC.fsti.checked"
],
"interface_file": false,
"source_file": "Benton2004.DDCC.Examples.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004.DDCC",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004.DDCC",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004.DDCC",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 128,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | x: Benton2004.var -> phi: Benton2004.DDCC.sttype -> z: Benton2004.var
-> FStar.Pervasives.Lemma
(requires Benton2004.DDCC.st_fresh_in x phi /\ Benton2004.DDCC.st_fresh_in z phi /\ x <> z)
(ensures
Benton2004.DDCC.st_fresh_in x phi /\ Benton2004.DDCC.st_fresh_in z phi /\ x <> z /\
Benton2004.DDCC.exec_equiv (Benton2004.DDCC.st_cons (Benton2004.DDCC.st_cons phi
x
(Benton2004.DDCC.ns_singl 3))
z
Benton2004.DDCC.ns_t)
(Benton2004.DDCC.st_cons (Benton2004.DDCC.st_cons phi x Benton2004.DDCC.ns_t)
z
(Benton2004.DDCC.ns_singl 8))
(Benton2004.seq (Benton2004.assign x (Benton2004.const 7))
(Benton2004.assign z (Benton2004.const 8)))
(Benton2004.assign z (Benton2004.const 8))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.var",
"Benton2004.DDCC.sttype",
"Benton2004.DDCC.d_su1'",
"Prims.unit",
"Benton2004.DDCC.d_assign",
"Benton2004.DDCC.st_cons",
"Benton2004.DDCC.ns_t",
"Prims.int",
"Benton2004.DDCC.ns_singl",
"Benton2004.const",
"Benton2004.DDCC.d_das",
"Benton2004.computation",
"Benton2004.assign",
"Prims.l_and",
"Benton2004.DDCC.st_fresh_in",
"Prims.b2t",
"Prims.op_disEquality",
"Prims.squash",
"Benton2004.DDCC.exec_equiv",
"Benton2004.seq",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let fig3_d3 (x: var) (phi: sttype) (z: var)
: Lemma (requires (x `st_fresh_in` phi /\ z `st_fresh_in` phi /\ x <> z))
(ensures
(x `st_fresh_in` phi /\ z `st_fresh_in` phi /\ x <> z /\
exec_equiv (st_cons (st_cons phi x (ns_singl 3)) z ns_t)
(st_cons (st_cons phi x ns_t) z (ns_singl 8))
(seq (assign x (const 7)) (assign z (const 8)))
(assign z (const 8)))) =
| let c = assign x (const 7) in
let c' = assign z (const 8) in
let c'' = c' in
let phi_ = st_cons (st_cons phi x (ns_singl 3)) z ns_t in
let phi' = st_cons (st_cons phi x ns_t) z ns_t in
let phi'' = st_cons (st_cons phi x ns_t) z (ns_singl 8) in
d_das x (const 7) (st_cons phi z ns_t) (ns_singl 3);
d_assign (st_cons phi x ns_t) z ns_t (ns_singl 8) (const 8) (const 8);
d_su1' c c' c'' phi_ phi' phi'' | false |
Benton2004.DDCC.Examples.fst | Benton2004.DDCC.Examples.fig3 | val fig3 (x: var) (phi: sttype) (z: var)
: Lemma (requires (x `st_fresh_in` phi /\ z `st_fresh_in` phi /\ x <> z))
(ensures
(x `st_fresh_in` phi /\ z `st_fresh_in` phi /\ x <> z /\
exec_equiv (st_cons (st_cons phi x (ns_singl 3)) z ns_t)
(st_cons (st_cons phi x ns_t) z (ns_singl 8))
(seq (ifthenelse (eop op_Equality (evar x) (const 3)) (assign x (const 7)) skip)
(assign z (eop op_Addition (evar x) (const 1))))
(assign z (const 8)))) | val fig3 (x: var) (phi: sttype) (z: var)
: Lemma (requires (x `st_fresh_in` phi /\ z `st_fresh_in` phi /\ x <> z))
(ensures
(x `st_fresh_in` phi /\ z `st_fresh_in` phi /\ x <> z /\
exec_equiv (st_cons (st_cons phi x (ns_singl 3)) z ns_t)
(st_cons (st_cons phi x ns_t) z (ns_singl 8))
(seq (ifthenelse (eop op_Equality (evar x) (const 3)) (assign x (const 7)) skip)
(assign z (eop op_Addition (evar x) (const 1))))
(assign z (const 8)))) | let fig3
(x: var)
(phi: sttype)
(z: var)
: Lemma
(requires (
x `st_fresh_in` phi /\
z `st_fresh_in` phi /\
x <> z
))
(ensures (
x `st_fresh_in` phi /\
z `st_fresh_in` phi /\
x <> z /\
exec_equiv
(st_cons (st_cons phi x (ns_singl 3)) z ns_t)
(st_cons (st_cons phi x ns_t) z (ns_singl 8))
(seq (ifthenelse (eop op_Equality (evar x) (const 3)) (assign x (const 7)) skip) (assign z (eop op_Addition (evar x) (const 1))))
(assign z (const 8))
))
= fig3_d1 x (st_cons phi z ns_t);
d_csub // this step is IMPLICIT, BENTON DID NOT MENTION IT IN THE PROOF TREE
(st_cons (st_cons phi z ns_t) x (ns_singl 3))
(st_cons (st_cons phi z ns_t) x (ns_singl 7))
(st_cons (st_cons phi x (ns_singl 3)) z ns_t)
(st_cons (st_cons phi x (ns_singl 7)) z ns_t)
(ifthenelse (eop op_Equality (evar x) (const 3)) (assign x (const 7)) skip)
(assign x (const 7));
fig3_d2 x phi z;
fig3_d3 x phi z | {
"file_name": "examples/rel/Benton2004.DDCC.Examples.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 17,
"end_line": 151,
"start_col": 0,
"start_line": 122
} | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Benton2004.DDCC.Examples
open Benton2004.DDCC
#reset-options "--z3rlimit 128"
let op_abs_singl
(#from #to: Type0)
(op: (from -> from -> Tot to))
(c1 c2: from)
: Lemma
(op_abs op (ns_singl c1) (ns_singl c2) (ns_singl (op c1 c2)))
= ()
let d_op_singl
(#from #to: Type0)
(op: (from -> from -> Tot to))
(c1 c2: from)
(e1 e1' e2 e2': exp from)
(phi: sttype)
: Lemma
(requires (
eval_equiv phi (ns_singl c1) e1 e1' /\
eval_equiv phi (ns_singl c2) e2 e2'
))
(ensures (eval_equiv phi (ns_singl (op c1 c2)) (eop op e1 e2) (eop op e1' e2')))
[SMTPat (eval_equiv phi (ns_singl (op c1 c2)) (eop op e1 e2) (eop op e1' e2'))]
= op_abs_singl op c1 c2 ;
d_op op e1 e1' e2 e2' (ns_singl c1) (ns_singl c2) (ns_singl (op c1 c2)) phi
let fig3_d1
(x: var)
(phi: sttype)
: Lemma
(requires (
x `st_fresh_in` phi
))
(ensures (
x `st_fresh_in` phi /\
exec_equiv
(st_cons phi x (ns_singl 3))
(st_cons phi x (ns_singl 7))
(ifthenelse (eop op_Equality (evar x) (const 3)) (assign x (const 7)) skip)
(assign x (const 7))
))
= d_op_singl (op_Equality #int) 3 3 (evar x) (evar x) (const 3) (const 3) (st_cons phi x (ns_singl 3))
// the rest is automatically inferred through patterns
let fig3_d2
(x: var)
(phi: sttype)
(z: var)
: Lemma
(requires (
x `st_fresh_in` phi /\
z `st_fresh_in` phi /\
x <> z
))
(ensures (
x `st_fresh_in` phi /\
z `st_fresh_in` phi /\
x <> z /\
exec_equiv
(st_cons (st_cons phi x (ns_singl 7)) z ns_t)
(st_cons (st_cons phi x ns_t) z (ns_singl 8))
(assign z (eop op_Addition (evar x) (const 1)))
(assign z (const 8))
))
= d_op_singl op_Addition 7 1 (evar x) (evar x) (const 1) (const 1) (st_cons phi x (ns_singl 7));
assert (
exec_equiv
(st_cons (st_cons phi x (ns_singl 7)) z ns_t)
(st_cons (st_cons phi x (ns_singl 7)) z (ns_singl 8))
(assign z (eop op_Addition (evar x) (const 1)))
(assign z (const 8))
)
let fig3_d3
(x: var)
(phi: sttype)
(z: var)
: Lemma
(requires (
x `st_fresh_in` phi /\
z `st_fresh_in` phi /\
x <> z
))
(ensures (
x `st_fresh_in` phi /\
z `st_fresh_in` phi /\
x <> z /\
exec_equiv
(st_cons (st_cons phi x (ns_singl 3)) z ns_t)
(st_cons (st_cons phi x ns_t) z (ns_singl 8))
(seq (assign x (const 7)) (assign z (const 8)))
(assign z (const 8))
))
= let c = assign x (const 7) in
let c' = assign z (const 8) in
let c'' = c' in
let phi_ = st_cons (st_cons phi x (ns_singl 3)) z ns_t in
let phi' = st_cons (st_cons phi x ns_t) z ns_t in
let phi'' = st_cons (st_cons phi x ns_t) z (ns_singl 8) in
d_das x (const 7) (st_cons phi z ns_t) (ns_singl 3);
d_assign (st_cons phi x ns_t) z ns_t (ns_singl 8) (const 8) (const 8);
d_su1' c c' c'' phi_ phi' phi'' // FIXME: WHY WHY WHY does the pattern on d_su1'' NOT trigger? | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"Benton2004.DDCC.fsti.checked"
],
"interface_file": false,
"source_file": "Benton2004.DDCC.Examples.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004.DDCC",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004.DDCC",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004.DDCC",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 128,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | x: Benton2004.var -> phi: Benton2004.DDCC.sttype -> z: Benton2004.var
-> FStar.Pervasives.Lemma
(requires Benton2004.DDCC.st_fresh_in x phi /\ Benton2004.DDCC.st_fresh_in z phi /\ x <> z)
(ensures
Benton2004.DDCC.st_fresh_in x phi /\ Benton2004.DDCC.st_fresh_in z phi /\ x <> z /\
Benton2004.DDCC.exec_equiv (Benton2004.DDCC.st_cons (Benton2004.DDCC.st_cons phi
x
(Benton2004.DDCC.ns_singl 3))
z
Benton2004.DDCC.ns_t)
(Benton2004.DDCC.st_cons (Benton2004.DDCC.st_cons phi x Benton2004.DDCC.ns_t)
z
(Benton2004.DDCC.ns_singl 8))
(Benton2004.seq (Benton2004.ifthenelse (Benton2004.eop Prims.op_Equality
(Benton2004.evar x)
(Benton2004.const 3))
(Benton2004.assign x (Benton2004.const 7))
Benton2004.skip)
(Benton2004.assign z
(Benton2004.eop Prims.op_Addition (Benton2004.evar x) (Benton2004.const 1))))
(Benton2004.assign z (Benton2004.const 8))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.var",
"Benton2004.DDCC.sttype",
"Benton2004.DDCC.Examples.fig3_d3",
"Prims.unit",
"Benton2004.DDCC.Examples.fig3_d2",
"Benton2004.DDCC.d_csub",
"Benton2004.DDCC.st_cons",
"Benton2004.DDCC.ns_t",
"Prims.int",
"Benton2004.DDCC.ns_singl",
"Benton2004.ifthenelse",
"Benton2004.eop",
"Prims.bool",
"Prims.op_Equality",
"Benton2004.evar",
"Benton2004.const",
"Benton2004.assign",
"Benton2004.skip",
"Benton2004.DDCC.Examples.fig3_d1",
"Prims.l_and",
"Benton2004.DDCC.st_fresh_in",
"Prims.b2t",
"Prims.op_disEquality",
"Prims.squash",
"Benton2004.DDCC.exec_equiv",
"Benton2004.seq",
"Prims.op_Addition",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let fig3 (x: var) (phi: sttype) (z: var)
: Lemma (requires (x `st_fresh_in` phi /\ z `st_fresh_in` phi /\ x <> z))
(ensures
(x `st_fresh_in` phi /\ z `st_fresh_in` phi /\ x <> z /\
exec_equiv (st_cons (st_cons phi x (ns_singl 3)) z ns_t)
(st_cons (st_cons phi x ns_t) z (ns_singl 8))
(seq (ifthenelse (eop op_Equality (evar x) (const 3)) (assign x (const 7)) skip)
(assign z (eop op_Addition (evar x) (const 1))))
(assign z (const 8)))) =
| fig3_d1 x (st_cons phi z ns_t);
d_csub (st_cons (st_cons phi z ns_t) x (ns_singl 3))
(st_cons (st_cons phi z ns_t) x (ns_singl 7))
(st_cons (st_cons phi x (ns_singl 3)) z ns_t)
(st_cons (st_cons phi x (ns_singl 7)) z ns_t)
(ifthenelse (eop op_Equality (evar x) (const 3)) (assign x (const 7)) skip)
(assign x (const 7));
fig3_d2 x phi z;
fig3_d3 x phi z | false |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.