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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Vale.X64.Leakage.fst | Vale.X64.Leakage.lemma_loop_explicit_leakage_free | val lemma_loop_explicit_leakage_free: (ts:analysis_taints) -> (code:S.code{While? code}) -> (s1:S.machine_state) -> (s2:S.machine_state) -> (fuel:nat) -> Lemma
(requires True)
(ensures (let b, ts' = check_if_loop_consumes_fixed_time code ts in
(b2t b ==> isConstantTimeGivenStates code fuel ts.lts s1 s2 /\ isExplicitLeakageFreeGivenStates code fuel ts.lts ts'.lts s1 s2)))
(decreases %[fuel; code; 0]) | val lemma_loop_explicit_leakage_free: (ts:analysis_taints) -> (code:S.code{While? code}) -> (s1:S.machine_state) -> (s2:S.machine_state) -> (fuel:nat) -> Lemma
(requires True)
(ensures (let b, ts' = check_if_loop_consumes_fixed_time code ts in
(b2t b ==> isConstantTimeGivenStates code fuel ts.lts s1 s2 /\ isExplicitLeakageFreeGivenStates code fuel ts.lts ts'.lts s1 s2)))
(decreases %[fuel; code; 0]) | let rec lemma_code_explicit_leakage_free ts code s1 s2 fuel = match code with
| Ins ins -> lemma_ins_leakage_free ts ins
| Block block -> lemma_block_explicit_leakage_free ts block s1 s2 fuel
| IfElse ifCond ifTrue ifFalse ->
reveal_opaque (`%S.valid_ocmp_opaque) S.valid_ocmp_opaque;
reveal_opaque (`%S.eval_ocmp_opaque) S.eval_ocmp_opaque;
let (b_fin, ts_fin) = check_if_code_consumes_fixed_time code ts in
let (st1, b1) = machine_eval_ocmp s1 ifCond in
let (st2, b2) = machine_eval_ocmp s2 ifCond in
assert (b2t b_fin ==> constTimeInvariant ts.lts s1 s2 /\ st1.S.ms_ok /\ st2.S.ms_ok ==> constTimeInvariant ts.lts st1 st2);
monotone_ok_eval ifTrue fuel st1;
monotone_ok_eval ifTrue fuel st2;
lemma_code_explicit_leakage_free ts ifTrue st1 st2 fuel;
monotone_ok_eval ifFalse fuel st1;
monotone_ok_eval ifFalse fuel st2;
lemma_code_explicit_leakage_free ts ifFalse st1 st2 fuel
| While _ _ -> lemma_loop_explicit_leakage_free ts code s1 s2 fuel
and lemma_block_explicit_leakage_free ts block s1 s2 fuel = match block with
| [] -> ()
| hd :: tl ->
let b, ts' = check_if_code_consumes_fixed_time hd ts in
lemma_code_explicit_leakage_free ts hd s1 s2 fuel;
let s'1 = machine_eval_code hd fuel s1 in
let s'2 = machine_eval_code hd fuel s2 in
if None? s'1 || None? s'2 then ()
else
let s'1 = Some?.v s'1 in
let s'2 = Some?.v s'2 in
lemma_block_explicit_leakage_free ts' tl s'1 s'2 fuel;
monotone_ok_eval (Block tl) fuel s'1;
monotone_ok_eval (Block tl) fuel s'2
and lemma_loop_explicit_leakage_free ts code s1 s2 fuel =
reveal_opaque (`%S.valid_ocmp_opaque) S.valid_ocmp_opaque;
reveal_opaque (`%S.eval_ocmp_opaque) S.eval_ocmp_opaque;
let ts = normalize_taints ts in
if fuel = 0 then () else
let (b_fin, ts_fin) = check_if_code_consumes_fixed_time code ts in
let r1 = machine_eval_code code fuel s1 in
let r2 = machine_eval_code code fuel s2 in
let While cond body = code in
let (st1, b1) = machine_eval_ocmp s1 cond in
let (st2, b2) = machine_eval_ocmp s2 cond in
assert (b2t b_fin ==> constTimeInvariant ts.lts s1 s2 /\ st1.S.ms_ok /\ st2.S.ms_ok ==> b1 = b2);
assert (b2t b_fin ==> constTimeInvariant ts.lts s1 s2 /\ st1.S.ms_ok /\ st2.S.ms_ok ==> constTimeInvariant ts.lts st1 st2);
if not b1 || not b2 then
(
assert (b2t b_fin ==> constTimeInvariant ts.lts s1 s2 /\ st1.S.ms_ok /\ st2.S.ms_ok ==> not b1 /\ not b2);
assert (not b1 ==> r1 == Some st1);
assert (not b2 ==> r2 == Some st2);
monotone_ok_eval_while code fuel s1;
assert (Some? r1 /\ (Some?.v r1).S.ms_ok ==> st1.S.ms_ok);
monotone_ok_eval_while code fuel s2;
assert (Some? r2 /\ (Some?.v r2).S.ms_ok ==> st2.S.ms_ok);
lemma_loop_taintstate_monotone ts code;
isExplicit_monotone ts ts ts_fin code fuel s1 s2;
()
)
else
(
assert (b2t b_fin ==> constTimeInvariant ts.lts s1 s2 /\ st1.S.ms_ok /\ st2.S.ms_ok ==> constTimeInvariant ts.lts st1 st2);
let (b', ts') = check_if_code_consumes_fixed_time body ts in
lemma_code_explicit_leakage_free ts body st1 st2 (fuel - 1);
monotone_ok_eval body (fuel - 1) st1;
monotone_ok_eval body (fuel - 1) st2;
let st1 = machine_eval_code body (fuel - 1) st1 in
let st2 = machine_eval_code body (fuel - 1) st2 in
assert (None? st1 ==> r1 == st1);
assert (None? st2 ==> r2 == st2);
if (None? st1 || None? st2) then () else
let st1 = Some?.v st1 in
let st2 = Some?.v st2 in
if not st1.S.ms_ok || not st2.S.ms_ok then () else
let combined_ts = combine_analysis_taints ts ts' in
let (b_aux, ts_aux) = check_if_loop_consumes_fixed_time code combined_ts in
lemma_loop_explicit_leakage_free combined_ts code st1 st2 (fuel - 1);
isConstant_monotone ts combined_ts code (fuel - 1) st1 st2;
isExplicit_monotone2 ts_aux ts combined_ts code (fuel - 1) st1 st2;
assert (b2t b_fin ==> constTimeInvariant ts.lts s1 s2 /\ st1.S.ms_ok /\ st2.S.ms_ok ==> constTimeInvariant ts'.lts st1 st2)
) | {
"file_name": "vale/code/arch/x64/Vale.X64.Leakage.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 431,
"start_col": 0,
"start_line": 350
} | module Vale.X64.Leakage
open FStar.Mul
open Vale.X64.Machine_s
module S = Vale.X64.Machine_Semantics_s
open Vale.X64.Leakage_s
open Vale.X64.Leakage_Helpers
open Vale.X64.Leakage_Ins
unfold let machine_eval_ocmp = S.machine_eval_ocmp
unfold let machine_eval_code = S.machine_eval_code
unfold let machine_eval_codes = S.machine_eval_codes
unfold let machine_eval_while = S.machine_eval_while
#reset-options "--initial_ifuel 0 --max_ifuel 1 --initial_fuel 1 --max_fuel 1"
let normalize_taints (ts:analysis_taints) : analysis_taints =
let AnalysisTaints lts rts = ts in
AnalysisTaints lts (regs_to_map (map_to_regs rts))
let combine_reg_taints (regs1 regs2:reg_taint) : reg_taint =
FunctionalExtensionality.on reg (fun x -> merge_taint (regs1 x) (regs2 x))
let rec eq_regs_file (regs1 regs2:reg_taint) (rf:reg_file_id) (k:nat{k <= n_regs rf}) : bool =
if k = 0 then true
else regs1 (Reg rf (k - 1)) = regs2 (Reg rf (k - 1)) && eq_regs_file regs1 regs2 rf (k - 1)
let rec eq_regs (regs1 regs2:reg_taint) (k:nat{k <= n_reg_files}) : bool =
if k = 0 then true
else eq_regs_file regs1 regs2 (k - 1) (n_regs (k - 1)) && eq_regs regs1 regs2 (k - 1)
let rec lemma_eq_regs_file (regs1 regs2:reg_taint) (rf:reg_file_id) (k:nat{k <= n_regs rf}) : Lemma
(ensures eq_regs_file regs1 regs2 rf k <==>
(forall (i:nat).{:pattern (Reg rf i)} i < k ==> regs1 (Reg rf i) == regs2 (Reg rf i)))
=
if k > 0 then lemma_eq_regs_file regs1 regs2 rf (k - 1)
let rec lemma_eq_regs (regs1 regs2:reg_taint) (k:nat{k <= n_reg_files}) : Lemma
(ensures
eq_regs regs1 regs2 k <==>
(forall (i j:nat).{:pattern (Reg i j)} i < k /\ j < n_regs i ==>
regs1 (Reg i j) == regs2 (Reg i j)))
=
if k > 0 then (
lemma_eq_regs_file regs1 regs2 (k - 1) (n_regs (k - 1));
lemma_eq_regs regs1 regs2 (k - 1)
)
let eq_registers (regs1 regs2:reg_taint) : (b:bool{b <==> regs1 == regs2}) =
lemma_eq_regs regs1 regs2 n_reg_files;
let b = eq_regs regs1 regs2 n_reg_files in
if b then (
assert (FStar.FunctionalExtensionality.feq regs1 regs2)
);
b
let eq_leakage_taints (ts1 ts2:leakage_taints) : (b:bool{b <==> ts1 == ts2}) =
eq_registers ts1.regTaint ts2.regTaint &&
ts1.flagsTaint = ts2.flagsTaint &&
ts1.cfFlagsTaint = ts2.cfFlagsTaint &&
ts1.ofFlagsTaint = ts2.ofFlagsTaint
let taintstate_monotone_regs (ts ts':reg_taint) =
(forall (r:reg).{:pattern (ts' r) \/ (ts r)}
Public? (ts' r) ==> Public? (ts r))
let taintstate_monotone (ts ts':analysis_taints) =
let ts = ts.lts in
let ts' = ts'.lts in
taintstate_monotone_regs ts.regTaint ts'.regTaint /\
(Public? (ts'.flagsTaint) ==> Public? (ts.flagsTaint)) /\
(Public? (ts'.cfFlagsTaint) ==> Public? (ts.cfFlagsTaint)) /\
(Public? (ts'.ofFlagsTaint) ==> Public? (ts.ofFlagsTaint))
let taintstate_monotone_trans (ts1:analysis_taints) (ts2:analysis_taints) (ts3:analysis_taints)
: Lemma (taintstate_monotone ts1 ts2 /\ taintstate_monotone ts2 ts3 ==> taintstate_monotone ts1 ts3) = ()
let isConstant_monotone (ts1:analysis_taints) (ts2:analysis_taints) (code:S.code) (fuel:nat) (s1:S.machine_state) (s2:S.machine_state)
: Lemma (isConstantTimeGivenStates code fuel ts2.lts s1 s2 /\ taintstate_monotone ts1 ts2 ==> isConstantTimeGivenStates code fuel ts1.lts s1 s2)
= ()
let isExplicit_monotone (ts:analysis_taints) (ts1:analysis_taints) (ts2:analysis_taints) (code:S.code)
(fuel:nat) (s1:S.machine_state) (s2:S.machine_state)
: Lemma (isExplicitLeakageFreeGivenStates code fuel ts.lts ts1.lts s1 s2 /\ taintstate_monotone ts1 ts2 ==> isExplicitLeakageFreeGivenStates code fuel ts.lts ts2.lts s1 s2)
= ()
let isExplicit_monotone2 (ts:analysis_taints) (ts1:analysis_taints) (ts2:analysis_taints)
(code:S.code) (fuel:nat) (s1:S.machine_state) (s2:S.machine_state)
: Lemma (isExplicitLeakageFreeGivenStates code fuel ts2.lts ts.lts s1 s2 /\ taintstate_monotone ts1 ts2 ==> isExplicitLeakageFreeGivenStates code fuel ts1.lts ts.lts s1 s2)
= ()
let combine_leakage_taints (ts1:leakage_taints) (ts2:leakage_taints) : leakage_taints =
let LeakageTaints rs1 fs1 c1 o1 = ts1 in
let LeakageTaints rs2 fs2 c2 o2 = ts2 in
let rs = combine_reg_taints rs1 rs2 in
LeakageTaints
rs
(merge_taint fs1 fs2)
(merge_taint c1 c2)
(merge_taint o1 o2)
let combine_analysis_taints (ts1:analysis_taints) (ts2:analysis_taints)
: (ts:analysis_taints{taintstate_monotone ts1 ts /\ taintstate_monotone ts2 ts /\ ts.lts == combine_leakage_taints ts1.lts ts2.lts})
=
let AnalysisTaints (LeakageTaints rs1_old fs1 c1 o1) rts1 = ts1 in
let AnalysisTaints (LeakageTaints rs2_old fs2 c2 o2) rts2 = ts2 in
let rts1 = ts1.rts in
let rts2 = ts2.rts in
let rs1 = map_to_regs rts1 in // \
let rs2 = map_to_regs rts2 in // - build efficient representations of reg_taint before calling combine_reg_taints
assert (FStar.FunctionalExtensionality.feq rs1 rs1_old);
assert (FStar.FunctionalExtensionality.feq rs2 rs2_old);
let rs = combine_reg_taints rs1 rs2 in
let rts = regs_to_map rs in
let lts = LeakageTaints
rs
(merge_taint fs1 fs2)
(merge_taint c1 c2)
(merge_taint o1 o2)
in
AnalysisTaints lts rts
let count_public_register (regs:reg_taint) (r:reg) = if Public? (regs r) then 1 else 0
let rec count_public_registers_file (regs:reg_taint) (rf:reg_file_id) (k:nat{k <= n_regs rf}) : nat =
if k = 0 then 0
else count_public_register regs (Reg rf (k - 1)) + count_public_registers_file regs rf (k - 1)
let rec lemma_count_public_registers_file (regs1 regs2:reg_taint) (rf:reg_file_id) (k:nat{k <= n_regs rf}) : Lemma
(requires
taintstate_monotone_regs regs2 regs1 /\
count_public_registers_file regs1 rf k >= count_public_registers_file regs2 rf k
)
(ensures
count_public_registers_file regs1 rf k == count_public_registers_file regs2 rf k /\
(forall (i:nat).{:pattern regs1 (Reg rf i) \/ regs2 (Reg rf i)} i < k ==> regs1 (Reg rf i) == regs2 (Reg rf i))
)
=
if k > 0 then lemma_count_public_registers_file regs1 regs2 rf (k - 1)
let rec count_public_registers (regs:reg_taint) (k:nat{k <= n_reg_files}) : nat =
if k = 0 then 0
else count_public_registers_file regs (k - 1) (n_regs (k - 1)) + count_public_registers regs (k - 1)
let rec lemma_count_public_registers (regs1 regs2:reg_taint) (k:nat{k <= n_reg_files}) : Lemma
(requires
taintstate_monotone_regs regs2 regs1 /\
count_public_registers regs1 k >= count_public_registers regs2 k
)
(ensures
count_public_registers regs1 k == count_public_registers regs2 k /\
(forall (r:reg).{:pattern regs1 r \/ regs2 r} Reg?.rf r < k ==> regs1 r == regs2 r)
)
=
if k > 0 then (
let n = n_regs (k - 1) in
if count_public_registers_file regs1 (k - 1) n >= count_public_registers_file regs2 (k - 1) n then
lemma_count_public_registers_file regs1 regs2 (k - 1) n;
lemma_count_public_registers regs1 regs2 (k - 1)
)
let count_flagTaint (ts:analysis_taints) : nat = if Public? ts.lts.flagsTaint then 1 else 0
let count_cfFlagTaint (ts:analysis_taints) : nat = if Public? ts.lts.cfFlagsTaint then 1 else 0
let count_ofFlagTaint (ts:analysis_taints) : nat = if Public? ts.lts.ofFlagsTaint then 1 else 0
let count_publics (ts:analysis_taints) : nat =
count_public_registers ts.lts.regTaint n_reg_files +
count_flagTaint ts +
count_cfFlagTaint ts +
count_ofFlagTaint ts
let monotone_decreases_count (ts ts':analysis_taints) : Lemma
(requires taintstate_monotone ts ts' /\ not (eq_leakage_taints ts.lts ts'.lts))
(ensures count_publics ts' < count_publics ts)
=
let regs1 = ts'.lts.regTaint in
let regs2 = ts.lts.regTaint in
if count_public_registers regs1 n_reg_files >= count_public_registers regs2 n_reg_files then (
lemma_count_public_registers regs1 regs2 n_reg_files;
assert (FStar.FunctionalExtensionality.feq regs1 regs2)
)
val check_if_block_consumes_fixed_time (block:S.codes) (ts:analysis_taints) : Tot (bool & analysis_taints)
(decreases %[block])
val check_if_code_consumes_fixed_time (code:S.code) (ts:analysis_taints) : Tot (bool & analysis_taints)
(decreases %[code; count_publics ts; 1])
val check_if_loop_consumes_fixed_time (code:S.code{While? code}) (ts:analysis_taints) : Tot (bool & analysis_taints)
(decreases %[code; count_publics ts; 0])
#set-options "--z3refresh --z3rlimit 600"
let rec check_if_block_consumes_fixed_time (block:S.codes) (ts:analysis_taints) : bool & analysis_taints =
match block with
| [] -> true, ts
| hd::tl -> let fixedTime, ts_int = check_if_code_consumes_fixed_time hd ts in
if (not fixedTime) then fixedTime, ts_int
else check_if_block_consumes_fixed_time tl ts_int
and check_if_code_consumes_fixed_time (code:S.code) (ts:analysis_taints) : bool & analysis_taints =
match code with
| Ins ins -> let b, ts = check_if_ins_consumes_fixed_time ins ts in b, ts
| Block block -> check_if_block_consumes_fixed_time block ts
| IfElse ifCond ifTrue ifFalse ->
let o1 = operand_taint 0 (S.get_fst_ocmp ifCond) ts in
let o2 = operand_taint 0 (S.get_snd_ocmp ifCond) ts in
let predTaint = merge_taint o1 o2 in
if (Secret? predTaint) then (false, ts)
else
let o1Public = operand_does_not_use_secrets (S.get_fst_ocmp ifCond) ts in
if (not o1Public) then (false, ts)
else
let o2Public = operand_does_not_use_secrets (S.get_snd_ocmp ifCond) ts in
if (not o2Public) then (false, ts)
else
let validIfTrue, tsIfTrue = check_if_code_consumes_fixed_time ifTrue ts in
if (not validIfTrue) then (false, ts)
else
let validIfFalse, tsIfFalse = check_if_code_consumes_fixed_time ifFalse ts in
if (not validIfFalse) then (false, ts)
else
(true, combine_analysis_taints tsIfTrue tsIfFalse)
| While cond body -> check_if_loop_consumes_fixed_time code ts
and check_if_loop_consumes_fixed_time c (ts:analysis_taints) : (bool & analysis_taints) =
let ts = normalize_taints ts in
let While pred body = c in
let o1 = operand_taint 0 (S.get_fst_ocmp pred) ts in
let o2 = operand_taint 0 (S.get_snd_ocmp pred) ts in
let predTaint = merge_taint o1 o2 in
if (Secret? predTaint) then false, ts
else
let o1Public = operand_does_not_use_secrets (S.get_fst_ocmp pred) ts in
if (not o1Public) then (false, ts)
else
let o2Public = operand_does_not_use_secrets (S.get_snd_ocmp pred) ts in
if (not o2Public) then (false, ts)
else
let fixedTime, next_ts = check_if_code_consumes_fixed_time body ts in
if (not fixedTime) then (false, ts)
else
let combined_ts = combine_analysis_taints ts next_ts in
assert (taintstate_monotone ts combined_ts);
if eq_leakage_taints combined_ts.lts ts.lts then
true, combined_ts
else (
monotone_decreases_count ts combined_ts;
check_if_loop_consumes_fixed_time c combined_ts
)
val monotone_ok_eval: (code:S.code) -> (fuel:nat) -> (s:S.machine_state) -> Lemma
(requires True)
(ensures (let s' = machine_eval_code code fuel s in
Some? s' /\ (Some?.v s').S.ms_ok ==> s.S.ms_ok))
(decreases %[code; 0])
val monotone_ok_eval_block: (codes:S.codes) -> (fuel:nat) -> (s:S.machine_state) -> Lemma
(requires True)
(ensures (let s' = machine_eval_codes codes fuel s in
Some? s' /\ (Some?.v s').S.ms_ok ==> s.S.ms_ok))
(decreases %[codes;1])
#set-options "--z3rlimit 20 --initial_ifuel 0 --max_ifuel 1 --initial_fuel 2 --max_fuel 2"
let rec monotone_ok_eval code fuel s =
match code with
| Ins ins -> reveal_opaque (`%S.machine_eval_code_ins) S.machine_eval_code_ins
| Block block -> monotone_ok_eval_block block fuel s
| IfElse ifCond ifTrue ifFalse ->
let (st, b) = machine_eval_ocmp s ifCond in
if b then monotone_ok_eval ifTrue fuel st else monotone_ok_eval ifFalse fuel st
| While cond body ->
if fuel = 0 then ()
else
let (st, b) = machine_eval_ocmp s cond in
if not b then () else
monotone_ok_eval body (fuel - 1) st;
()
and monotone_ok_eval_block block fuel s =
match block with
| [] -> ()
| hd :: tl ->
let s' = machine_eval_code hd fuel s in
if None? s' then () else
monotone_ok_eval_block tl fuel (Some?.v s');
monotone_ok_eval hd fuel s
val monotone_ok_eval_while: (code:S.code{While? code}) -> (fuel:nat) -> (s:S.machine_state) -> Lemma
(requires True)
(ensures (
let While cond body = code in
let (s1, b1) = machine_eval_ocmp s cond in
let r1 = machine_eval_code code fuel s in
Some? r1 /\ (Some?.v r1).S.ms_ok ==> s1.S.ms_ok))
let monotone_ok_eval_while code fuel s =
let While cond body = code in
let (s1, b) = machine_eval_ocmp s cond in
let r1 = machine_eval_while cond body fuel s in
if fuel = 0 then () else
if not b then () else
match machine_eval_code body (fuel - 1) s1 with
| None -> ()
| Some s ->
if not s.S.ms_ok then ()
else (monotone_ok_eval body (fuel - 1) s1; monotone_ok_eval code (fuel - 1) s)
val lemma_loop_taintstate_monotone (ts:analysis_taints) (code:S.code{While? code}) : Lemma
(requires True)
(ensures (let _, ts' = check_if_loop_consumes_fixed_time code ts in
taintstate_monotone ts ts'))
(decreases %[count_publics ts])
#reset-options "--initial_ifuel 1 --max_ifuel 1 --initial_fuel 2 --max_fuel 2 --z3rlimit 40"
let rec lemma_loop_taintstate_monotone ts code =
let ts = normalize_taints ts in
let While pred body = code in
let b, ts' = check_if_code_consumes_fixed_time body ts in
let combined_ts = combine_analysis_taints ts ts' in
if eq_leakage_taints combined_ts.lts ts.lts then ()
else (
monotone_decreases_count ts combined_ts;
let b, ts_fin = check_if_loop_consumes_fixed_time code combined_ts in
lemma_loop_taintstate_monotone combined_ts code;
taintstate_monotone_trans ts combined_ts ts_fin
)
#reset-options "--initial_ifuel 1 --max_ifuel 1 --initial_fuel 2 --max_fuel 2 --z3rlimit 60"
val lemma_code_explicit_leakage_free: (ts:analysis_taints) -> (code:S.code) -> (s1:S.machine_state) -> (s2:S.machine_state) -> (fuel:nat) -> Lemma
(requires True)
(ensures (let b, ts' = check_if_code_consumes_fixed_time code ts in
(b2t b ==> isConstantTimeGivenStates code fuel ts.lts s1 s2 /\ isExplicitLeakageFreeGivenStates code fuel ts.lts ts'.lts s1 s2)))
(decreases %[fuel; code; 1])
val lemma_block_explicit_leakage_free: (ts:analysis_taints) -> (codes:S.codes) -> (s1:S.machine_state) -> (s2:S.machine_state) -> (fuel:nat) -> Lemma
(requires True)
(ensures (let b, ts' = check_if_block_consumes_fixed_time codes ts in
(b2t b ==> isConstantTimeGivenStates (Block codes) fuel ts.lts s1 s2 /\ isExplicitLeakageFreeGivenStates (Block codes) fuel ts.lts ts'.lts s1 s2)))
(decreases %[fuel; codes; 2])
val lemma_loop_explicit_leakage_free: (ts:analysis_taints) -> (code:S.code{While? code}) -> (s1:S.machine_state) -> (s2:S.machine_state) -> (fuel:nat) -> Lemma
(requires True)
(ensures (let b, ts' = check_if_loop_consumes_fixed_time code ts in
(b2t b ==> isConstantTimeGivenStates code fuel ts.lts s1 s2 /\ isExplicitLeakageFreeGivenStates code fuel ts.lts ts'.lts s1 s2)))
(decreases %[fuel; code; 0]) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Leakage_s.fst.checked",
"Vale.X64.Leakage_Ins.fsti.checked",
"Vale.X64.Leakage_Helpers.fst.checked",
"Vale.Lib.MapTree.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.Leakage.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_Ins",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_Ins",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_Helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Leakage_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.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": 1,
"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": 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": 300,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
ts: Vale.X64.Leakage_Helpers.analysis_taints ->
code: Vale.X64.Machine_Semantics_s.code{While? code} ->
s1: Vale.X64.Machine_Semantics_s.machine_state ->
s2: Vale.X64.Machine_Semantics_s.machine_state ->
fuel: Prims.nat
-> FStar.Pervasives.Lemma
(ensures
(let _ = Vale.X64.Leakage.check_if_loop_consumes_fixed_time code ts in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ b ts' = _ in
b ==>
Vale.X64.Leakage_s.isConstantTimeGivenStates code fuel (AnalysisTaints?.lts ts) s1 s2 /\
Vale.X64.Leakage_s.isExplicitLeakageFreeGivenStates code
fuel
(AnalysisTaints?.lts ts)
(AnalysisTaints?.lts ts')
s1
s2)
<:
Type0)) (decreases %[fuel;code;0]) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [
"lemma_code_explicit_leakage_free",
"lemma_block_explicit_leakage_free",
"lemma_loop_explicit_leakage_free"
] | [
"Vale.X64.Leakage_Helpers.analysis_taints",
"Vale.X64.Machine_Semantics_s.code",
"Prims.b2t",
"Vale.X64.Machine_s.uu___is_While",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Vale.X64.Bytes_Code_s.ocmp",
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"Vale.X64.Machine_s.precode",
"Prims.op_BarBar",
"Prims.op_Negation",
"Prims.unit",
"Vale.X64.Leakage.isExplicit_monotone",
"Vale.X64.Leakage.lemma_loop_taintstate_monotone",
"Prims._assert",
"Prims.l_imp",
"Prims.l_and",
"FStar.Pervasives.Native.uu___is_Some",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_ok",
"FStar.Pervasives.Native.__proj__Some__item__v",
"Vale.X64.Leakage.monotone_ok_eval_while",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.Some",
"Vale.X64.Leakage_s.constTimeInvariant",
"Vale.X64.Leakage_Helpers.__proj__AnalysisTaints__item__lts",
"FStar.Pervasives.Native.uu___is_None",
"Vale.X64.Leakage.isExplicit_monotone2",
"Prims.op_Subtraction",
"Vale.X64.Leakage.isConstant_monotone",
"Vale.X64.Leakage.lemma_loop_explicit_leakage_free",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.Leakage.check_if_loop_consumes_fixed_time",
"Vale.X64.Leakage.taintstate_monotone",
"Vale.X64.Leakage_s.leakage_taints",
"Vale.X64.Leakage.combine_leakage_taints",
"Vale.X64.Leakage.combine_analysis_taints",
"Vale.X64.Leakage.machine_eval_code",
"Vale.X64.Leakage.monotone_ok_eval",
"Vale.X64.Leakage.lemma_code_explicit_leakage_free",
"Vale.X64.Leakage.check_if_code_consumes_fixed_time",
"Vale.X64.Leakage.machine_eval_ocmp",
"Vale.X64.Leakage.normalize_taints",
"FStar.Pervasives.reveal_opaque",
"Vale.X64.Machine_Semantics_s.ocmp",
"Vale.X64.Machine_Semantics_s.eval_ocmp_opaque",
"Vale.X64.Machine_Semantics_s.valid_ocmp_opaque"
] | [
"mutual recursion"
] | false | false | true | false | false | let rec lemma_loop_explicit_leakage_free ts code s1 s2 fuel =
| reveal_opaque (`%S.valid_ocmp_opaque) S.valid_ocmp_opaque;
reveal_opaque (`%S.eval_ocmp_opaque) S.eval_ocmp_opaque;
let ts = normalize_taints ts in
if fuel = 0
then ()
else
let b_fin, ts_fin = check_if_code_consumes_fixed_time code ts in
let r1 = machine_eval_code code fuel s1 in
let r2 = machine_eval_code code fuel s2 in
let While cond body = code in
let st1, b1 = machine_eval_ocmp s1 cond in
let st2, b2 = machine_eval_ocmp s2 cond in
assert (b2t b_fin ==> constTimeInvariant ts.lts s1 s2 /\ st1.S.ms_ok /\ st2.S.ms_ok ==> b1 = b2);
assert (b2t b_fin ==>
constTimeInvariant ts.lts s1 s2 /\ st1.S.ms_ok /\ st2.S.ms_ok ==>
constTimeInvariant ts.lts st1 st2);
if not b1 || not b2
then
(assert (b2t b_fin ==>
constTimeInvariant ts.lts s1 s2 /\ st1.S.ms_ok /\ st2.S.ms_ok ==> not b1 /\ not b2);
assert (not b1 ==> r1 == Some st1);
assert (not b2 ==> r2 == Some st2);
monotone_ok_eval_while code fuel s1;
assert (Some? r1 /\ (Some?.v r1).S.ms_ok ==> st1.S.ms_ok);
monotone_ok_eval_while code fuel s2;
assert (Some? r2 /\ (Some?.v r2).S.ms_ok ==> st2.S.ms_ok);
lemma_loop_taintstate_monotone ts code;
isExplicit_monotone ts ts ts_fin code fuel s1 s2;
())
else
(assert (b2t b_fin ==>
constTimeInvariant ts.lts s1 s2 /\ st1.S.ms_ok /\ st2.S.ms_ok ==>
constTimeInvariant ts.lts st1 st2);
let b', ts' = check_if_code_consumes_fixed_time body ts in
lemma_code_explicit_leakage_free ts body st1 st2 (fuel - 1);
monotone_ok_eval body (fuel - 1) st1;
monotone_ok_eval body (fuel - 1) st2;
let st1 = machine_eval_code body (fuel - 1) st1 in
let st2 = machine_eval_code body (fuel - 1) st2 in
assert (None? st1 ==> r1 == st1);
assert (None? st2 ==> r2 == st2);
if (None? st1 || None? st2)
then ()
else
let st1 = Some?.v st1 in
let st2 = Some?.v st2 in
if not st1.S.ms_ok || not st2.S.ms_ok
then ()
else
let combined_ts = combine_analysis_taints ts ts' in
let b_aux, ts_aux = check_if_loop_consumes_fixed_time code combined_ts in
lemma_loop_explicit_leakage_free combined_ts code st1 st2 (fuel - 1);
isConstant_monotone ts combined_ts code (fuel - 1) st1 st2;
isExplicit_monotone2 ts_aux ts combined_ts code (fuel - 1) st1 st2;
assert (b2t b_fin ==>
constTimeInvariant ts.lts s1 s2 /\ st1.S.ms_ok /\ st2.S.ms_ok ==>
constTimeInvariant ts'.lts st1 st2)) | false |
Spec.Frodo.Sample.fst | Spec.Frodo.Sample.frodo_sample_fc | val frodo_sample_fc:
a:frodo_alg
-> t:uint16
-> i:size_nat{i <= cdf_table_len a}
-> GTot (res:nat{0 <= res /\ res <= i})
(decreases i) | val frodo_sample_fc:
a:frodo_alg
-> t:uint16
-> i:size_nat{i <= cdf_table_len a}
-> GTot (res:nat{0 <= res /\ res <= i})
(decreases i) | let rec frodo_sample_fc a t i =
if i = 0 then 0
else frodo_sample_f a t (i - 1) + frodo_sample_fc a t (i - 1) | {
"file_name": "specs/frodo/Spec.Frodo.Sample.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 63,
"end_line": 38,
"start_col": 0,
"start_line": 36
} | module Spec.Frodo.Sample
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
open Spec.Frodo.Lemmas
open Spec.Frodo.Params
module LSeq = Lib.Sequence
module Matrix = Spec.Matrix
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val frodo_sample_f:
a:frodo_alg
-> t:uint16
-> i:size_nat{i < cdf_table_len a}
-> res:nat{res = 0 \/ res = 1}
let frodo_sample_f a t i =
if v t > v (cdf_table a).[i] then 1 else 0
val frodo_sample_fc:
a:frodo_alg
-> t:uint16
-> i:size_nat{i <= cdf_table_len a}
-> GTot (res:nat{0 <= res /\ res <= i})
(decreases i) | {
"checked_file": "/",
"dependencies": [
"Spec.Matrix.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.Lemmas.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Sample.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Spec.Matrix",
"short_module": "Matrix"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Frodo.Params.frodo_alg ->
t: Lib.IntTypes.uint16 ->
i: Lib.IntTypes.size_nat{i <= Spec.Frodo.Params.cdf_table_len a}
-> Prims.GTot (res: Prims.nat{0 <= res /\ res <= i}) | Prims.GTot | [
"sometrivial",
""
] | [] | [
"Spec.Frodo.Params.frodo_alg",
"Lib.IntTypes.uint16",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Spec.Frodo.Params.cdf_table_len",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"Prims.op_Addition",
"Spec.Frodo.Sample.frodo_sample_f",
"Prims.op_Subtraction",
"Spec.Frodo.Sample.frodo_sample_fc",
"Prims.nat",
"Prims.l_and"
] | [
"recursion"
] | false | false | false | false | false | let rec frodo_sample_fc a t i =
| if i = 0 then 0 else frodo_sample_f a t (i - 1) + frodo_sample_fc a t (i - 1) | false |
FStar.InteractiveHelpers.Base.fst | FStar.InteractiveHelpers.Base._generate_shadowed_subst | val _generate_shadowed_subst (ge: genv) (t: term) (bvl: list (bv & typ))
: Tac (genv & list (bv & typ & bv)) | val _generate_shadowed_subst (ge: genv) (t: term) (bvl: list (bv & typ))
: Tac (genv & list (bv & typ & bv)) | let rec _generate_shadowed_subst (ge:genv) (t:term) (bvl : list (bv & typ)) :
Tac (genv & list (bv & typ & bv)) =
match bvl with
| [] -> ge, []
| old_bv :: bvl' ->
match inspect t with
| Tv_Abs b _ ->
(* Introduce the new binder *)
let bv = (inspect_binder b).binder_bv in
let bvv = inspect_bv bv in
let ty = binder_sort b in
let name = unseal bvv.bv_ppname in
let ge1, fresh = genv_push_fresh_bv ge ("__" ^ name) ty in
let t1 = mk_e_app t [pack (Tv_Var fresh)] in
let t2 = norm_term_env ge1.env [] t1 in
(* Recursion *)
let ge2, nbvl = _generate_shadowed_subst ge1 t2 bvl' in
(* Return *)
ge2, (fst old_bv, ty, fresh) :: nbvl
| _ -> mfail "_subst_with_fresh_vars: not a Tv_Abs" | {
"file_name": "ulib/experimental/FStar.InteractiveHelpers.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 55,
"end_line": 624,
"start_col": 0,
"start_line": 605
} | module FStar.InteractiveHelpers.Base
open FStar.List
open FStar.Tactics
open FStar.Mul
#push-options "--z3rlimit 15 --fuel 0 --ifuel 1"
(*** Utilities *)
val bv_eq : bv -> bv -> Tot bool
let bv_eq (bv1 bv2 : bv) =
let bvv1 = inspect_bv bv1 in
let bvv2 = inspect_bv bv2 in
(* We don't check for type equality: the fact that no two different binders
* have the same name and index is an invariant which must be enforced -
* and actually we could limit ourselves to checking the index *)
bvv1.bv_index = bvv2.bv_index
val fv_eq : fv -> fv -> Tot bool
let fv_eq fv1 fv2 =
let n1 = inspect_fv fv1 in
let n2 = inspect_fv fv2 in
n1 = n2
// TODO: use everywhere
val fv_eq_name : fv -> name -> Tot bool
let fv_eq_name fv n =
let fvn = inspect_fv fv in
fvn = n
// TODO: use more
val opt_apply (#a #b : Type) (f : a -> Tot b) (x : option a) : Tot (option b)
let opt_apply #a #b f x =
match x with
| None -> None
| Some x' -> Some (f x')
val opt_tapply (#a #b : Type) (f : a -> Tac b) (x : option a) : Tac (option b)
let opt_tapply #a #b f x =
match x with
| None -> None
| Some x' -> Some (f x')
val option_to_string : (#a : Type) -> (a -> Tac string) -> option a -> Tac string
let option_to_string #a f x =
match x with
| None -> "None"
| Some x' -> "Some (" ^ f x' ^ ")"
let opt_cons (#a : Type) (opt_x : option a) (ls : list a) : Tot (list a) =
match opt_x with
| Some x -> x :: ls
| None -> ls
val list_to_string : #a : Type -> (a -> Tac string) -> list a -> Tac string
let list_to_string #a f ls =
(Tactics.Util.fold_left (fun s x -> s ^ " (" ^ f x ^ ");") "[" ls) ^ "]"
/// Apply a term to a list of parameters, normalize the result to make sure
/// all the abstractions are simplified
val mk_app_norm : env -> term -> list term -> Tac term
let mk_app_norm e t params =
let t1 = mk_e_app t params in
let t2 = norm_term_env e [] t1 in
t2
val opt_mk_app_norm : env -> option term -> list term -> Tac (option term)
let opt_mk_app_norm e opt_t params =
opt_tapply (fun t -> mk_app_norm e t params) opt_t
// TODO: remove
let rec unzip #a #b (l : list (a & b)) : Tot (list a & list b) =
match l with
| [] -> ([],[])
| (hd1,hd2)::tl ->
let (tl1,tl2) = unzip tl in
(hd1::tl1,hd2::tl2)
/// Alternative ``bv_to_string`` function where we print the index of the bv.
/// It can be very useful for debugging.
let abv_to_string bv : Tac string =
let bvv = inspect_bv bv in
name_of_bv bv ^ " (%" ^ string_of_int (bvv.bv_index) ^ ")"
let print_binder_info (full : bool) (b : binder) : Tac unit =
let open inspect_binder b <: binder_view in
let qual_str = match binder_qual with
| Q_Implicit -> "Implicit"
| Q_Explicit -> "Explicit"
| Q_Meta t -> "Meta: " ^ term_to_string t
in
let bview = inspect_bv binder_bv in
if full then
print (
"> print_binder_info:" ^
"\n- name: " ^ (name_of_binder b) ^
"\n- as string: " ^ (binder_to_string b) ^
"\n- aqual: " ^ qual_str ^
"\n- ppname: " ^ name_of_bv binder_bv ^
"\n- index: " ^ string_of_int bview.bv_index ^
"\n- sort: " ^ term_to_string binder_sort
)
else print (binder_to_string b)
let print_binders_info (full : bool) (e:env) : Tac unit =
iter (print_binder_info full) (binders_of_env e)
let acomp_to_string (c:comp) : Tac string =
match inspect_comp c with
| C_Total ret ->
"C_Total (" ^ term_to_string ret ^ ")"
| C_GTotal ret ->
"C_GTotal (" ^ term_to_string ret ^ ")"
| C_Lemma pre post patterns ->
"C_Lemma (" ^ term_to_string pre ^ ") (" ^ term_to_string post ^ ")"
| C_Eff us eff_name result eff_args _ ->
let eff_arg_to_string (a : term) : Tac string =
" (" ^ term_to_string a ^ ")"
in
let args_str = map (fun (x, y) -> eff_arg_to_string x) eff_args in
let args_str = List.Tot.fold_left (fun x y -> x ^ y) "" args_str in
"C_Eff (" ^ flatten_name eff_name ^ ") (" ^ term_to_string result ^ ")" ^ args_str
exception MetaAnalysis of string
let mfail str =
raise (MetaAnalysis str)
(*** Debugging *)
/// Some debugging facilities
val print_dbg : bool -> string -> Tac unit
let print_dbg debug s =
if debug then print s
/// Return the qualifier of a term as a string
val term_view_construct (t : term_view) : Tac string
let term_view_construct (t : term_view) : Tac string =
match t with
| Tv_Var _ -> "Tv_Var"
| Tv_BVar _ -> "Tv_BVar"
| Tv_FVar _ -> "Tv_FVar"
| Tv_App _ _ -> "Tv_App"
| Tv_Abs _ _ -> "Tv_Abs"
| Tv_Arrow _ _ -> "Tv_Arrow"
| Tv_Type _ -> "Tv_Type"
| Tv_Refine _ _ _ -> "Tv_Refine"
| Tv_Const _ -> "Tv_Const"
| Tv_Uvar _ _ -> "Tv_Uvar"
| Tv_Let _ _ _ _ _ _ -> "Tv_Let"
| Tv_Match _ _ _ -> "Tv_Match"
| Tv_AscribedT _ _ _ _ -> "Tv_AscribedT"
| Tv_AscribedC _ _ _ _ -> "Tv_AScribedC"
| _ -> "Tv_Unknown"
val term_construct (t : term) : Tac string
let term_construct (t : term) : Tac string =
term_view_construct (inspect t)
(*** Pretty printing *)
/// There are many issues linked to terms (pretty) printing.
/// The first issue is that when parsing terms, F* automatically inserts
/// ascriptions, which then clutter the terms printed to the user. The current
/// workaround is to filter those ascriptions in the terms before exploiting them.
/// TODO: this actually doesn't work for some unknown reason: some terms like [a /\ b]
/// become [l_and a b]...
val filter_ascriptions : bool -> term -> Tac term
let filter_ascriptions dbg t =
print_dbg dbg ("[> filter_ascriptions: " ^ term_view_construct t ^ ": " ^ term_to_string t );
visit_tm (fun t ->
match inspect t with
| Tv_AscribedT e _ _ _
| Tv_AscribedC e _ _ _ -> e
| _ -> t) t
/// Our prettification function. Apply it to all the terms which might be printed
/// back to the user. Note that the time at which the function is applied is
/// important: we can't apply it on all the assertions we export to the user, just
/// before exporting, because we may have inserted ascriptions on purpose, which
/// would then be filtered away.
val prettify_term : bool -> term -> Tac term
let prettify_term dbg t = filter_ascriptions dbg t
(*** Environments *)
/// We need a way to handle environments with variable bindings
/// and name shadowing, to properly display the context to the user.
/// A map linking variables to terms. For now we use a list to define it, because
/// there shouldn't be too many bindings.
type bind_map (a : Type) = list (bv & a)
let bind_map_push (#a:Type) (m:bind_map a) (b:bv) (x:a) = (b,x)::m
let rec bind_map_get (#a:Type) (m:bind_map a) (b:bv) : Tot (option a) =
match m with
| [] -> None
| (b', x)::m' ->
if compare_bv b b' = Order.Eq then Some x else bind_map_get m' b
let rec bind_map_get_from_name (#a:Type) (m:bind_map a) (name:string) :
Tac (option (bv & a)) =
match m with
| [] -> None
| (b', x)::m' ->
let b'v = inspect_bv b' in
if unseal b'v.bv_ppname = name then Some (b', x) else bind_map_get_from_name m' name
noeq type genv =
{
env : env;
(* Whenever we evaluate a let binding, we keep track of the relation between
* the binder and its definition.
* The boolean indicates whether or not the variable is considered abstract. We
* often need to introduce variables which don't appear in the user context, for
* example when we need to deal with a postcondition for Stack or ST, which handles
* the previous and new memory states, and which may not be available in the user
* context, or where we don't always know which variable to use.
* In this case, whenever we output the term, we write its content as an
* abstraction applied to those missing parameters. For instance, in the
* case of the assertion introduced for a post-condition:
* [> assert((fun h1 h2 -> post) h1 h2);
* Besides the informative goal, the user can replace those parameters (h1
* and h2 above) by the proper ones then normalize the assertion by using
* the appropriate command to get a valid assertion. *)
bmap : bind_map (typ & bool & term);
(* Whenever we introduce a new variable, we check whether it shadows another
* variable because it has the same name, and put it in the below
* list. Of course, for the F* internals such shadowing is not an issue, because
* the index of every variable should be different, but this is very important
* when generating code for the user *)
svars : list (bv & typ);
}
let get_env (e:genv) : env = e.env
let get_bind_map (e:genv) : bind_map (typ & bool & term) = e.bmap
let mk_genv env bmap svars : genv = Mkgenv env bmap svars
let mk_init_genv env : genv = mk_genv env [] []
val genv_to_string : genv -> Tac string
let genv_to_string ge =
let binder_to_string (b : binder) : Tac string =
abv_to_string (bv_of_binder b) ^ "\n"
in
let binders_str = map binder_to_string (binders_of_env ge.env) in
let bmap_elem_to_string (e : bv & (typ & bool & term)) : Tac string =
let bv, (_sort, abs, t) = e in
"(" ^ abv_to_string bv ^" -> (" ^
string_of_bool abs ^ ", " ^ term_to_string t ^ "))\n"
in
let bmap_str = map bmap_elem_to_string ge.bmap in
let svars_str = map (fun (bv, _) -> abv_to_string bv ^ "\n") ge.svars in
let flatten = List.Tot.fold_left (fun x y -> x ^ y) "" in
"> env:\n" ^ flatten binders_str ^
"> bmap:\n" ^ flatten bmap_str ^
"> svars:\n" ^ flatten svars_str
let genv_get (ge:genv) (b:bv) : Tot (option (typ & bool & term)) =
bind_map_get ge.bmap b
let genv_get_from_name (ge:genv) (name:string) : Tac (option ((bv & typ) & (bool & term))) =
(* tweak return a bit to include sort *)
match bind_map_get_from_name ge.bmap name with
| None -> None
| Some (bv, (sort, b, x)) -> Some ((bv, sort), (b, x))
/// Push a binder to a ``genv``. Optionally takes a ``term`` which provides the
/// term the binder is bound to (in a `let _ = _ in` construct for example).
let genv_push_bv (ge:genv) (b:bv) (sort:typ) (abs:bool) (t:option term) : Tac genv =
let br = mk_binder b sort in
let sv = genv_get_from_name ge (name_of_bv b) in
let svars' = if Some? sv then fst (Some?.v sv) :: ge.svars else ge.svars in
let e' = push_binder ge.env br in
let tm = if Some? t then Some?.v t else pack (Tv_Var b) in
let bmap' = bind_map_push ge.bmap b (sort, abs, tm) in
mk_genv e' bmap' svars'
let genv_push_binder (ge:genv) (b:binder) (abs:bool) (t:option term) : Tac genv =
genv_push_bv ge (bv_of_binder b) (binder_sort b) abs t
/// Check if a binder is shadowed by another more recent binder
let bv_is_shadowed (ge : genv) (bv : bv) : Tot bool =
List.Tot.existsb (fun (b,_) -> bv_eq bv b) ge.svars
let binder_is_shadowed (ge : genv) (b : binder) : Tot bool =
bv_is_shadowed ge (bv_of_binder b)
let find_shadowed_bvs (ge : genv) (bl : list bv) : Tot (list (bv & bool)) =
List.Tot.map (fun b -> b, bv_is_shadowed ge b) bl
let find_shadowed_binders (ge : genv) (bl : list binder) : Tot (list (binder & bool)) =
List.Tot.map (fun b -> b, binder_is_shadowed ge b) bl
val bv_is_abstract : genv -> bv -> Tot bool
let bv_is_abstract ge bv =
match genv_get ge bv with
| None -> false
| Some (_, abs, _) -> abs
val binder_is_abstract : genv -> binder -> Tot bool
let binder_is_abstract ge b =
bv_is_abstract ge (bv_of_binder b)
val genv_abstract_bvs : genv -> Tot (list (bv & typ))
let genv_abstract_bvs ge =
List.Tot.concatMap
(fun (bv, (ty, abs, _)) -> if abs then [bv,ty] else []) ge.bmap
/// Versions of ``fresh_bv`` and ``fresh_binder`` inspired by the standard library
/// We make sure the name is fresh because we need to be able to generate valid code
/// (it is thus not enough to have a fresh integer).
let rec _fresh_bv binder_names basename i : Tac bv =
let name = basename ^ string_of_int i in
(* In worst case the performance is quadratic in the number of binders.
* TODO: fix that, it actually probably happens for anonymous variables ('_') *)
if List.mem name binder_names then _fresh_bv binder_names basename (i+1)
else fresh_bv_named name
let fresh_bv (e : env) (basename : string) : Tac bv =
let binders = binders_of_env e in
let binder_names = Tactics.map name_of_binder binders in
_fresh_bv binder_names basename 0
let fresh_binder (e : env) (basename : string) (ty : typ) : Tac binder =
let bv = fresh_bv e basename in
mk_binder bv ty
let genv_push_fresh_binder (ge : genv) (basename : string) (ty : typ) : Tac (genv & binder) =
let b = fresh_binder ge.env basename ty in
(* TODO: we can have a shortcircuit push (which performs less checks) *)
let ge' = genv_push_binder ge b true None in
ge', b
// TODO: actually we should use push_fresh_bv more
let push_fresh_binder (e : env) (basename : string) (ty : typ) : Tac (env & binder) =
let b = fresh_binder e basename ty in
let e' = push_binder e b in
e', b
let genv_push_fresh_bv (ge : genv) (basename : string) (ty : typ) : Tac (genv & bv) =
let ge', b = genv_push_fresh_binder ge basename ty in
ge', bv_of_binder b
val push_fresh_var : env -> string -> typ -> Tac (term & binder & env)
let push_fresh_var e0 basename ty =
let e1, b1 = push_fresh_binder e0 basename ty in
let v1 = pack (Tv_Var (bv_of_binder b1)) in
v1, b1, e1
val genv_push_fresh_var : genv -> string -> typ -> Tac (term & binder & genv)
let genv_push_fresh_var ge0 basename ty =
let ge1, b1 = genv_push_fresh_binder ge0 basename ty in
let v1 = pack (Tv_Var (bv_of_binder b1)) in
v1, b1, ge1
val push_two_fresh_vars : env -> string -> typ -> Tac (term & binder & term & binder & env)
let push_two_fresh_vars e0 basename ty =
let e1, b1 = push_fresh_binder e0 basename ty in
let e2, b2 = push_fresh_binder e1 basename ty in
let v1 = pack (Tv_Var (bv_of_binder b1)) in
let v2 = pack (Tv_Var (bv_of_binder b2)) in
v1, b1, v2, b2, e2
val genv_push_two_fresh_vars : genv -> string -> typ -> Tac (term & binder & term & binder & genv)
let genv_push_two_fresh_vars ge0 basename ty =
let ge1, b1 = genv_push_fresh_binder ge0 basename ty in
let ge2, b2 = genv_push_fresh_binder ge1 basename ty in
let v1 = pack (Tv_Var (bv_of_binder b1)) in
let v2 = pack (Tv_Var (bv_of_binder b2)) in
v1, b1, v2, b2, ge2
(*** Substitutions *)
/// Substitutions
/// Custom substitutions using the normalizer. This is the easiest and safest
/// way to perform a substitution: if you want to substitute [v] with [t] in [exp],
/// just normalize [(fun v -> exp) t]. Note that this may be computationally expensive.
val norm_apply_subst : env -> term -> list ((bv & typ) & term) -> Tac term
val norm_apply_subst_in_comp : env -> comp -> list ((bv & typ) & term) -> Tac comp
let norm_apply_subst e t subst =
let bl, vl = unzip subst in
let bl = List.Tot.map (fun (bv,ty) -> mk_binder bv ty) bl in
let t1 = mk_abs bl t in
let t2 = mk_e_app t1 vl in
norm_term_env e [] t2
let norm_apply_subst_in_comp e c subst =
let subst = (fun x -> norm_apply_subst e x subst) in
let subst_in_aqualv a : Tac aqualv =
match a with
| Q_Implicit
| Q_Explicit -> a
| Q_Meta t -> Q_Meta (subst t)
in
match inspect_comp c with
| C_Total ret ->
let ret = subst ret in
pack_comp (C_Total ret)
| C_GTotal ret ->
let ret = subst ret in
pack_comp (C_GTotal ret)
| C_Lemma pre post patterns ->
let pre = subst pre in
let post = subst post in
let patterns = subst patterns in
pack_comp (C_Lemma pre post patterns)
| C_Eff us eff_name result eff_args decrs ->
let result = subst result in
let eff_args = map (fun (x, a) -> (subst x, subst_in_aqualv a)) eff_args in
let decrs = map subst decrs in
pack_comp (C_Eff us eff_name result eff_args decrs)
/// As substitution with normalization is very expensive, we implemented another
/// technique which works by exploring terms. This is super fast, but the terms
/// seem not to be reconstructed in the same way, which has a big impact on pretty printing.
/// For example, terms like [A /\ B] get printed as [Prims.l_and A B].
val deep_apply_subst : env -> term -> list (bv & term) -> Tac term
// Whenever we encounter a construction which introduces a binder, we need to apply
// the substitution in the binder type. Note that this gives a new binder, with
// which we need to replace the old one in what follows.
// Also note that it should be possible to rewrite [deep_apply_subst] in terms of [visit_tm],
// but [deep_apply_subst] seems to be a bit more precise with regard to type replacements (not
// sure it is really important, though).
val deep_apply_subst_in_bv : env -> bv -> list (bv & term) -> Tac (bv & list (bv & term))
val deep_apply_subst_in_binder : env -> binder -> list (bv & term) -> Tac (binder & list (bv & term))
val deep_apply_subst_in_comp : env -> comp -> list (bv & term) -> Tac comp
val deep_apply_subst_in_pattern : env -> pattern -> list (bv & term) -> Tac (pattern & list (bv & term))
let rec deep_apply_subst e t subst =
match inspect t with
| Tv_Var b ->
begin match bind_map_get subst b with
| None -> t
| Some t' -> t'
end
| Tv_BVar b ->
(* Note: Tv_BVar shouldn't happen *)
begin match bind_map_get subst b with
| None -> t
| Some t' -> t'
end
| Tv_FVar _ -> t
| Tv_App hd (a,qual) ->
let hd = deep_apply_subst e hd subst in
let a = deep_apply_subst e a subst in
pack (Tv_App hd (a, qual))
| Tv_Abs br body ->
let body = deep_apply_subst e body subst in
pack (Tv_Abs br body)
| Tv_Arrow br c ->
let br, subst = deep_apply_subst_in_binder e br subst in
let c = deep_apply_subst_in_comp e c subst in
pack (Tv_Arrow br c)
| Tv_Type _ -> t
| Tv_Refine bv sort ref ->
let sort = deep_apply_subst e sort subst in
let bv, subst = deep_apply_subst_in_bv e bv subst in
let ref = deep_apply_subst e ref subst in
pack (Tv_Refine bv sort ref)
| Tv_Const _ -> t
| Tv_Uvar _ _ -> t
| Tv_Let recf attrs bv ty def body ->
(* No need to substitute in the attributes - that we filter for safety *)
let ty = deep_apply_subst e ty subst in
let def = deep_apply_subst e def subst in
let bv, subst = deep_apply_subst_in_bv e bv subst in
let body = deep_apply_subst e body subst in
pack (Tv_Let recf [] bv ty def body)
| Tv_Match scrutinee ret_opt branches -> (* TODO: type of pattern variables *)
let scrutinee = deep_apply_subst e scrutinee subst in
let ret_opt = map_opt (fun (b, asc) ->
let b, subst = deep_apply_subst_in_binder e b subst in
let asc =
match asc with
| Inl t, tacopt, use_eq ->
Inl (deep_apply_subst e t subst),
map_opt (fun tac -> deep_apply_subst e tac subst) tacopt,
use_eq
| Inr c, tacopt, use_eq ->
Inr (deep_apply_subst_in_comp e c subst),
map_opt (fun tac -> deep_apply_subst e tac subst) tacopt,
use_eq in
b, asc) ret_opt in
(* For the branches: we don't need to explore the patterns *)
let deep_apply_subst_in_branch branch =
let pat, tm = branch in
let pat, subst = deep_apply_subst_in_pattern e pat subst in
let tm = deep_apply_subst e tm subst in
pat, tm
in
let branches = map deep_apply_subst_in_branch branches in
pack (Tv_Match scrutinee ret_opt branches)
| Tv_AscribedT exp ty tac use_eq ->
let exp = deep_apply_subst e exp subst in
let ty = deep_apply_subst e ty subst in
(* no need to apply it on the tactic - that we filter for safety *)
pack (Tv_AscribedT exp ty None use_eq)
| Tv_AscribedC exp c tac use_eq ->
let exp = deep_apply_subst e exp subst in
let c = deep_apply_subst_in_comp e c subst in
(* no need to apply it on the tactic - that we filter for safety *)
pack (Tv_AscribedC exp c None use_eq)
| _ ->
(* Unknown *)
t
and deep_apply_subst_in_bv e bv subst =
(* No substitution needs to happen for variables
(there is no longer a sort). But, shift the substitution. *)
bv, (bv, pack (Tv_Var bv))::subst
(*
* AR: TODO: should apply subst in attrs?
*)
and deep_apply_subst_in_binder e br subst =
let open inspect_binder br <: binder_view in
let binder_sort = deep_apply_subst e binder_sort subst in
let binder_bv, subst = deep_apply_subst_in_bv e binder_bv subst in
pack_binder {
binder_bv=binder_bv;
binder_qual=binder_qual;
binder_attrs=binder_attrs;
binder_sort=binder_sort;
}, subst
and deep_apply_subst_in_comp e c subst =
let subst = (fun x -> deep_apply_subst e x subst) in
let subst_in_aqualv a : Tac aqualv =
match a with
| Q_Implicit
| Q_Explicit -> a
| Q_Meta t -> Q_Meta (subst t)
in
match inspect_comp c with
| C_Total ret ->
let ret = subst ret in
pack_comp (C_Total ret)
| C_GTotal ret ->
let ret = subst ret in
pack_comp (C_GTotal ret)
| C_Lemma pre post patterns ->
let pre = subst pre in
let post = subst post in
let patterns = subst patterns in
pack_comp (C_Lemma pre post patterns)
| C_Eff us eff_name result eff_args decrs ->
let result = subst result in
let eff_args = map (fun (x, a) -> (subst x, subst_in_aqualv a)) eff_args in
let decrs = map subst decrs in
pack_comp (C_Eff us eff_name result eff_args decrs)
and deep_apply_subst_in_pattern e pat subst =
match pat with
| Pat_Constant _ -> pat, subst
| Pat_Cons fv us patterns ->
(* The types of the variables in the patterns should be independent of each
* other: we use fold_left only to incrementally update the substitution *)
let patterns, subst =
fold_right (fun (pat, b) (pats, subst) ->
let pat, subst = deep_apply_subst_in_pattern e pat subst in
((pat, b) :: pats, subst)) patterns ([], subst)
in
Pat_Cons fv us patterns, subst
| Pat_Var bv st ->
let st = Sealed.seal (deep_apply_subst e (unseal st) subst) in
let bv, subst = deep_apply_subst_in_bv e bv subst in
Pat_Var bv st, subst
| Pat_Dot_Term eopt ->
Pat_Dot_Term (map_opt (fun t -> deep_apply_subst e t subst) eopt), subst
/// The substitution functions actually used in the rest of the meta F* functions.
/// For now, we use normalization because even though it is sometimes slow it
/// gives prettier terms, and readability is the priority. In order to mitigate
/// the performance issue, we try to minimize the number of calls to those functions,
/// by doing lazy instantiations for example (rather than incrementally apply
/// substitutions in a term, accumulate the substitutions and perform them all at once).
/// TODO: would it be good to have a native substitution function in F*
let apply_subst = norm_apply_subst
let apply_subst_in_comp = norm_apply_subst_in_comp
val opt_apply_subst : env -> option term -> list ((bv & typ) & term) -> Tac (option term)
let opt_apply_subst e opt_t subst =
match opt_t with
| None -> None
| Some t -> Some (apply_subst e t subst)
(*** Variable shadowing *)
/// Introduce fresh variables to generate a substitution for the variables shadowed
/// in the current environment.
val generate_shadowed_subst : genv -> Tac (genv & list (bv & typ & bv))
/// In order to introduce variables with coherent types (the variables' types
/// may be dependent) and make things simpler, we build one big term:
/// [> (fun x1 x2 ... xn -> ())
/// Then, for each variable, we introduce a fresh variable with the same type as
/// the outermost abstraction, apply the above term to this new variable and
/// normalize to "apply" the substitution and reveal the next binding. | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.Util.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked"
],
"interface_file": false,
"source_file": "FStar.InteractiveHelpers.Base.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.InteractiveHelpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.InteractiveHelpers",
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 15,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
ge: FStar.InteractiveHelpers.Base.genv ->
t: FStar.Stubs.Reflection.Types.term ->
bvl: Prims.list (FStar.Stubs.Reflection.Types.bv * FStar.Stubs.Reflection.Types.typ)
-> FStar.Tactics.Effect.Tac
(FStar.InteractiveHelpers.Base.genv *
Prims.list ((FStar.Stubs.Reflection.Types.bv * FStar.Stubs.Reflection.Types.typ) *
FStar.Stubs.Reflection.Types.bv)) | FStar.Tactics.Effect.Tac | [] | [] | [
"FStar.InteractiveHelpers.Base.genv",
"FStar.Stubs.Reflection.Types.term",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"FStar.Stubs.Reflection.Types.bv",
"FStar.Stubs.Reflection.Types.typ",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.tuple3",
"Prims.Nil",
"FStar.Stubs.Reflection.Types.binder",
"Prims.Cons",
"FStar.Pervasives.Native.Mktuple3",
"FStar.Pervasives.Native.fst",
"FStar.InteractiveHelpers.Base._generate_shadowed_subst",
"FStar.Stubs.Tactics.V1.Builtins.norm_term_env",
"FStar.InteractiveHelpers.Base.__proj__Mkgenv__item__env",
"FStar.Pervasives.norm_step",
"FStar.Reflection.V1.Derived.mk_e_app",
"FStar.Stubs.Tactics.V1.Builtins.pack",
"FStar.Stubs.Reflection.V1.Data.Tv_Var",
"FStar.InteractiveHelpers.Base.genv_push_fresh_bv",
"Prims.op_Hat",
"Prims.string",
"FStar.Tactics.Unseal.unseal",
"FStar.Stubs.Reflection.V1.Data.__proj__Mkbv_view__item__bv_ppname",
"FStar.Tactics.V1.Derived.binder_sort",
"FStar.Stubs.Reflection.V1.Data.bv_view",
"Prims.precedes",
"FStar.Stubs.Reflection.V1.Builtins.inspect_bv",
"FStar.Stubs.Reflection.V1.Data.__proj__Mkbinder_view__item__binder_bv",
"FStar.Stubs.Reflection.V1.Builtins.inspect_binder",
"FStar.Stubs.Reflection.V1.Data.term_view",
"FStar.InteractiveHelpers.Base.mfail",
"FStar.Stubs.Tactics.V1.Builtins.inspect"
] | [
"recursion"
] | false | true | false | false | false | let rec _generate_shadowed_subst (ge: genv) (t: term) (bvl: list (bv & typ))
: Tac (genv & list (bv & typ & bv)) =
| match bvl with
| [] -> ge, []
| old_bv :: bvl' ->
match inspect t with
| Tv_Abs b _ ->
let bv = (inspect_binder b).binder_bv in
let bvv = inspect_bv bv in
let ty = binder_sort b in
let name = unseal bvv.bv_ppname in
let ge1, fresh = genv_push_fresh_bv ge ("__" ^ name) ty in
let t1 = mk_e_app t [pack (Tv_Var fresh)] in
let t2 = norm_term_env ge1.env [] t1 in
let ge2, nbvl = _generate_shadowed_subst ge1 t2 bvl' in
ge2, (fst old_bv, ty, fresh) :: nbvl
| _ -> mfail "_subst_with_fresh_vars: not a Tv_Abs" | false |
Test.Vectors.Chacha20Poly1305.fst | Test.Vectors.Chacha20Poly1305.output7 | val output7:(b: B.buffer UInt8.t {B.length b = 528 /\ B.recallable b}) | val output7:(b: B.buffer UInt8.t {B.length b = 528 /\ B.recallable b}) | let output7: (b: B.buffer UInt8.t { B.length b = 528 /\ B.recallable b }) =
[@inline_let] let l = [ 0x14uy; 0xf6uy; 0x41uy; 0x37uy; 0xa6uy; 0xd4uy; 0x27uy; 0xcduy; 0xdbuy; 0x06uy; 0x3euy; 0x9auy; 0x4euy; 0xabuy; 0xd5uy; 0xb1uy; 0x1euy; 0x6buy; 0xd2uy; 0xbcuy; 0x11uy; 0xf4uy; 0x28uy; 0x93uy; 0x63uy; 0x54uy; 0xefuy; 0xbbuy; 0x5euy; 0x1duy; 0x3auy; 0x1duy; 0x37uy; 0x3cuy; 0x0auy; 0x6cuy; 0x1euy; 0xc2uy; 0xd1uy; 0x2cuy; 0xb5uy; 0xa3uy; 0xb5uy; 0x7buy; 0xb8uy; 0x8fuy; 0x25uy; 0xa6uy; 0x1buy; 0x61uy; 0x1cuy; 0xecuy; 0x28uy; 0x58uy; 0x26uy; 0xa4uy; 0xa8uy; 0x33uy; 0x28uy; 0x25uy; 0x5cuy; 0x45uy; 0x05uy; 0xe5uy; 0x6cuy; 0x99uy; 0xe5uy; 0x45uy; 0xc4uy; 0xa2uy; 0x03uy; 0x84uy; 0x03uy; 0x73uy; 0x1euy; 0x8cuy; 0x49uy; 0xacuy; 0x20uy; 0xdduy; 0x8duy; 0xb3uy; 0xc4uy; 0xf5uy; 0xe7uy; 0x4fuy; 0xf1uy; 0xeduy; 0xa1uy; 0x98uy; 0xdeuy; 0xa4uy; 0x96uy; 0xdduy; 0x2fuy; 0xabuy; 0xabuy; 0x97uy; 0xcfuy; 0x3euy; 0xd2uy; 0x9euy; 0xb8uy; 0x13uy; 0x07uy; 0x28uy; 0x29uy; 0x19uy; 0xafuy; 0xfduy; 0xf2uy; 0x49uy; 0x43uy; 0xeauy; 0x49uy; 0x26uy; 0x91uy; 0xc1uy; 0x07uy; 0xd6uy; 0xbbuy; 0x81uy; 0x75uy; 0x35uy; 0x0duy; 0x24uy; 0x7fuy; 0xc8uy; 0xdauy; 0xd4uy; 0xb7uy; 0xebuy; 0xe8uy; 0x5cuy; 0x09uy; 0xa2uy; 0x2fuy; 0xdcuy; 0x28uy; 0x7duy; 0x3auy; 0x03uy; 0xfauy; 0x94uy; 0xb5uy; 0x1duy; 0x17uy; 0x99uy; 0x36uy; 0xc3uy; 0x1cuy; 0x18uy; 0x34uy; 0xe3uy; 0x9fuy; 0xf5uy; 0x55uy; 0x7cuy; 0xb0uy; 0x60uy; 0x9duy; 0xffuy; 0xacuy; 0xd4uy; 0x61uy; 0xf2uy; 0xaduy; 0xf8uy; 0xceuy; 0xc7uy; 0xbeuy; 0x5cuy; 0xd2uy; 0x95uy; 0xa8uy; 0x4buy; 0x77uy; 0x13uy; 0x19uy; 0x59uy; 0x26uy; 0xc9uy; 0xb7uy; 0x8fuy; 0x6auy; 0xcbuy; 0x2duy; 0x37uy; 0x91uy; 0xeauy; 0x92uy; 0x9cuy; 0x94uy; 0x5buy; 0xdauy; 0x0buy; 0xceuy; 0xfeuy; 0x30uy; 0x20uy; 0xf8uy; 0x51uy; 0xaduy; 0xf2uy; 0xbeuy; 0xe7uy; 0xc7uy; 0xffuy; 0xb3uy; 0x33uy; 0x91uy; 0x6auy; 0xc9uy; 0x1auy; 0x41uy; 0xc9uy; 0x0fuy; 0xf3uy; 0x10uy; 0x0euy; 0xfduy; 0x53uy; 0xffuy; 0x6cuy; 0x16uy; 0x52uy; 0xd9uy; 0xf3uy; 0xf7uy; 0x98uy; 0x2euy; 0xc9uy; 0x07uy; 0x31uy; 0x2cuy; 0x0cuy; 0x72uy; 0xd7uy; 0xc5uy; 0xc6uy; 0x08uy; 0x2auy; 0x7buy; 0xdauy; 0xbduy; 0x7euy; 0x02uy; 0xeauy; 0x1auy; 0xbbuy; 0xf2uy; 0x04uy; 0x27uy; 0x61uy; 0x28uy; 0x8euy; 0xf5uy; 0x04uy; 0x03uy; 0x1fuy; 0x4cuy; 0x07uy; 0x55uy; 0x82uy; 0xecuy; 0x1euy; 0xd7uy; 0x8buy; 0x2fuy; 0x65uy; 0x56uy; 0xd1uy; 0xd9uy; 0x1euy; 0x3cuy; 0xe9uy; 0x1fuy; 0x5euy; 0x98uy; 0x70uy; 0x38uy; 0x4auy; 0x8cuy; 0x49uy; 0xc5uy; 0x43uy; 0xa0uy; 0xa1uy; 0x8buy; 0x74uy; 0x9duy; 0x4cuy; 0x62uy; 0x0duy; 0x10uy; 0x0cuy; 0xf4uy; 0x6cuy; 0x8fuy; 0xe0uy; 0xaauy; 0x9auy; 0x8duy; 0xb7uy; 0xe0uy; 0xbeuy; 0x4cuy; 0x87uy; 0xf1uy; 0x98uy; 0x2fuy; 0xccuy; 0xeduy; 0xc0uy; 0x52uy; 0x29uy; 0xdcuy; 0x83uy; 0xf8uy; 0xfcuy; 0x2cuy; 0x0euy; 0xa8uy; 0x51uy; 0x4duy; 0x80uy; 0x0duy; 0xa3uy; 0xfeuy; 0xd8uy; 0x37uy; 0xe7uy; 0x41uy; 0x24uy; 0xfcuy; 0xfbuy; 0x75uy; 0xe3uy; 0x71uy; 0x7buy; 0x57uy; 0x45uy; 0xf5uy; 0x97uy; 0x73uy; 0x65uy; 0x63uy; 0x14uy; 0x74uy; 0xb8uy; 0x82uy; 0x9fuy; 0xf8uy; 0x60uy; 0x2fuy; 0x8auy; 0xf2uy; 0x4euy; 0xf1uy; 0x39uy; 0xdauy; 0x33uy; 0x91uy; 0xf8uy; 0x36uy; 0xe0uy; 0x8duy; 0x3fuy; 0x1fuy; 0x3buy; 0x56uy; 0xdcuy; 0xa0uy; 0x8fuy; 0x3cuy; 0x9duy; 0x71uy; 0x52uy; 0xa7uy; 0xb8uy; 0xc0uy; 0xa5uy; 0xc6uy; 0xa2uy; 0x73uy; 0xdauy; 0xf4uy; 0x4buy; 0x74uy; 0x5buy; 0x00uy; 0x3duy; 0x99uy; 0xd7uy; 0x96uy; 0xbauy; 0xe6uy; 0xe1uy; 0xa6uy; 0x96uy; 0x38uy; 0xaduy; 0xb3uy; 0xc0uy; 0xd2uy; 0xbauy; 0x91uy; 0x6buy; 0xf9uy; 0x19uy; 0xdduy; 0x3buy; 0xbeuy; 0xbeuy; 0x9cuy; 0x20uy; 0x50uy; 0xbauy; 0xa1uy; 0xd0uy; 0xceuy; 0x11uy; 0xbduy; 0x95uy; 0xd8uy; 0xd1uy; 0xdduy; 0x33uy; 0x85uy; 0x74uy; 0xdcuy; 0xdbuy; 0x66uy; 0x76uy; 0x44uy; 0xdcuy; 0x03uy; 0x74uy; 0x48uy; 0x35uy; 0x98uy; 0xb1uy; 0x18uy; 0x47uy; 0x94uy; 0x7duy; 0xffuy; 0x62uy; 0xe4uy; 0x58uy; 0x78uy; 0xabuy; 0xeduy; 0x95uy; 0x36uy; 0xd9uy; 0x84uy; 0x91uy; 0x82uy; 0x64uy; 0x41uy; 0xbbuy; 0x58uy; 0xe6uy; 0x1cuy; 0x20uy; 0x6duy; 0x15uy; 0x6buy; 0x13uy; 0x96uy; 0xe8uy; 0x35uy; 0x7fuy; 0xdcuy; 0x40uy; 0x2cuy; 0xe9uy; 0xbcuy; 0x8auy; 0x4fuy; 0x92uy; 0xecuy; 0x06uy; 0x2duy; 0x50uy; 0xdfuy; 0x93uy; 0x5duy; 0x65uy; 0x5auy; 0xa8uy; 0xfcuy; 0x20uy; 0x50uy; 0x14uy; 0xa9uy; 0x8auy; 0x7euy; 0x1duy; 0x08uy; 0x1fuy; 0xe2uy; 0x99uy; 0xd0uy; 0xbeuy; 0xfbuy; 0x3auy; 0x21uy; 0x9duy; 0xaduy; 0x86uy; 0x54uy; 0xfduy; 0x0duy; 0x98uy; 0x1cuy; 0x5auy; 0x6fuy; 0x1fuy; 0x9auy; 0x40uy; 0xcduy; 0xa2uy; 0xffuy; 0x6auy; 0xf1uy; 0x54uy; ] in
assert_norm (List.Tot.length l = 528);
B.gcmalloc_of_list HyperStack.root l | {
"file_name": "providers/test/vectors/Test.Vectors.Chacha20Poly1305.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 322,
"start_col": 0,
"start_line": 319
} | module Test.Vectors.Chacha20Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x1cuy; 0x92uy; 0x40uy; 0xa5uy; 0xebuy; 0x55uy; 0xd3uy; 0x8auy; 0xf3uy; 0x33uy; 0x88uy; 0x86uy; 0x04uy; 0xf6uy; 0xb5uy; 0xf0uy; 0x47uy; 0x39uy; 0x17uy; 0xc1uy; 0x40uy; 0x2buy; 0x80uy; 0x09uy; 0x9duy; 0xcauy; 0x5cuy; 0xbcuy; 0x20uy; 0x70uy; 0x75uy; 0xc0uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let nonce0: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce0_len: (x:UInt32.t { UInt32.v x = B.length nonce0 }) =
12ul
let aad0: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0x33uy; 0x88uy; 0x86uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x4euy; 0x91uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad0_len: (x:UInt32.t { UInt32.v x = B.length aad0 }) =
12ul
let input0: (b: B.buffer UInt8.t { B.length b = 265 /\ B.recallable b /\ B.disjoint b aad0 }) =
B.recall aad0;[@inline_let] let l = [ 0x49uy; 0x6euy; 0x74uy; 0x65uy; 0x72uy; 0x6euy; 0x65uy; 0x74uy; 0x2duy; 0x44uy; 0x72uy; 0x61uy; 0x66uy; 0x74uy; 0x73uy; 0x20uy; 0x61uy; 0x72uy; 0x65uy; 0x20uy; 0x64uy; 0x72uy; 0x61uy; 0x66uy; 0x74uy; 0x20uy; 0x64uy; 0x6fuy; 0x63uy; 0x75uy; 0x6duy; 0x65uy; 0x6euy; 0x74uy; 0x73uy; 0x20uy; 0x76uy; 0x61uy; 0x6cuy; 0x69uy; 0x64uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x61uy; 0x20uy; 0x6duy; 0x61uy; 0x78uy; 0x69uy; 0x6duy; 0x75uy; 0x6duy; 0x20uy; 0x6fuy; 0x66uy; 0x20uy; 0x73uy; 0x69uy; 0x78uy; 0x20uy; 0x6duy; 0x6fuy; 0x6euy; 0x74uy; 0x68uy; 0x73uy; 0x20uy; 0x61uy; 0x6euy; 0x64uy; 0x20uy; 0x6duy; 0x61uy; 0x79uy; 0x20uy; 0x62uy; 0x65uy; 0x20uy; 0x75uy; 0x70uy; 0x64uy; 0x61uy; 0x74uy; 0x65uy; 0x64uy; 0x2cuy; 0x20uy; 0x72uy; 0x65uy; 0x70uy; 0x6cuy; 0x61uy; 0x63uy; 0x65uy; 0x64uy; 0x2cuy; 0x20uy; 0x6fuy; 0x72uy; 0x20uy; 0x6fuy; 0x62uy; 0x73uy; 0x6fuy; 0x6cuy; 0x65uy; 0x74uy; 0x65uy; 0x64uy; 0x20uy; 0x62uy; 0x79uy; 0x20uy; 0x6fuy; 0x74uy; 0x68uy; 0x65uy; 0x72uy; 0x20uy; 0x64uy; 0x6fuy; 0x63uy; 0x75uy; 0x6duy; 0x65uy; 0x6euy; 0x74uy; 0x73uy; 0x20uy; 0x61uy; 0x74uy; 0x20uy; 0x61uy; 0x6euy; 0x79uy; 0x20uy; 0x74uy; 0x69uy; 0x6duy; 0x65uy; 0x2euy; 0x20uy; 0x49uy; 0x74uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x6euy; 0x61uy; 0x70uy; 0x70uy; 0x72uy; 0x6fuy; 0x70uy; 0x72uy; 0x69uy; 0x61uy; 0x74uy; 0x65uy; 0x20uy; 0x74uy; 0x6fuy; 0x20uy; 0x75uy; 0x73uy; 0x65uy; 0x20uy; 0x49uy; 0x6euy; 0x74uy; 0x65uy; 0x72uy; 0x6euy; 0x65uy; 0x74uy; 0x2duy; 0x44uy; 0x72uy; 0x61uy; 0x66uy; 0x74uy; 0x73uy; 0x20uy; 0x61uy; 0x73uy; 0x20uy; 0x72uy; 0x65uy; 0x66uy; 0x65uy; 0x72uy; 0x65uy; 0x6euy; 0x63uy; 0x65uy; 0x20uy; 0x6duy; 0x61uy; 0x74uy; 0x65uy; 0x72uy; 0x69uy; 0x61uy; 0x6cuy; 0x20uy; 0x6fuy; 0x72uy; 0x20uy; 0x74uy; 0x6fuy; 0x20uy; 0x63uy; 0x69uy; 0x74uy; 0x65uy; 0x20uy; 0x74uy; 0x68uy; 0x65uy; 0x6duy; 0x20uy; 0x6fuy; 0x74uy; 0x68uy; 0x65uy; 0x72uy; 0x20uy; 0x74uy; 0x68uy; 0x61uy; 0x6euy; 0x20uy; 0x61uy; 0x73uy; 0x20uy; 0x2fuy; 0xe2uy; 0x80uy; 0x9cuy; 0x77uy; 0x6fuy; 0x72uy; 0x6buy; 0x20uy; 0x69uy; 0x6euy; 0x20uy; 0x70uy; 0x72uy; 0x6fuy; 0x67uy; 0x72uy; 0x65uy; 0x73uy; 0x73uy; 0x2euy; 0x2fuy; 0xe2uy; 0x80uy; 0x9duy; ] in
assert_norm (List.Tot.length l = 265);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
265ul
let output0: (b: B.buffer UInt8.t { B.length b = 281 /\ B.recallable b }) =
[@inline_let] let l = [ 0x64uy; 0xa0uy; 0x86uy; 0x15uy; 0x75uy; 0x86uy; 0x1auy; 0xf4uy; 0x60uy; 0xf0uy; 0x62uy; 0xc7uy; 0x9buy; 0xe6uy; 0x43uy; 0xbduy; 0x5euy; 0x80uy; 0x5cuy; 0xfduy; 0x34uy; 0x5cuy; 0xf3uy; 0x89uy; 0xf1uy; 0x08uy; 0x67uy; 0x0auy; 0xc7uy; 0x6cuy; 0x8cuy; 0xb2uy; 0x4cuy; 0x6cuy; 0xfcuy; 0x18uy; 0x75uy; 0x5duy; 0x43uy; 0xeeuy; 0xa0uy; 0x9euy; 0xe9uy; 0x4euy; 0x38uy; 0x2duy; 0x26uy; 0xb0uy; 0xbduy; 0xb7uy; 0xb7uy; 0x3cuy; 0x32uy; 0x1buy; 0x01uy; 0x00uy; 0xd4uy; 0xf0uy; 0x3buy; 0x7fuy; 0x35uy; 0x58uy; 0x94uy; 0xcfuy; 0x33uy; 0x2fuy; 0x83uy; 0x0euy; 0x71uy; 0x0buy; 0x97uy; 0xceuy; 0x98uy; 0xc8uy; 0xa8uy; 0x4auy; 0xbduy; 0x0buy; 0x94uy; 0x81uy; 0x14uy; 0xaduy; 0x17uy; 0x6euy; 0x00uy; 0x8duy; 0x33uy; 0xbduy; 0x60uy; 0xf9uy; 0x82uy; 0xb1uy; 0xffuy; 0x37uy; 0xc8uy; 0x55uy; 0x97uy; 0x97uy; 0xa0uy; 0x6euy; 0xf4uy; 0xf0uy; 0xefuy; 0x61uy; 0xc1uy; 0x86uy; 0x32uy; 0x4euy; 0x2buy; 0x35uy; 0x06uy; 0x38uy; 0x36uy; 0x06uy; 0x90uy; 0x7buy; 0x6auy; 0x7cuy; 0x02uy; 0xb0uy; 0xf9uy; 0xf6uy; 0x15uy; 0x7buy; 0x53uy; 0xc8uy; 0x67uy; 0xe4uy; 0xb9uy; 0x16uy; 0x6cuy; 0x76uy; 0x7buy; 0x80uy; 0x4duy; 0x46uy; 0xa5uy; 0x9buy; 0x52uy; 0x16uy; 0xcduy; 0xe7uy; 0xa4uy; 0xe9uy; 0x90uy; 0x40uy; 0xc5uy; 0xa4uy; 0x04uy; 0x33uy; 0x22uy; 0x5euy; 0xe2uy; 0x82uy; 0xa1uy; 0xb0uy; 0xa0uy; 0x6cuy; 0x52uy; 0x3euy; 0xafuy; 0x45uy; 0x34uy; 0xd7uy; 0xf8uy; 0x3fuy; 0xa1uy; 0x15uy; 0x5buy; 0x00uy; 0x47uy; 0x71uy; 0x8cuy; 0xbcuy; 0x54uy; 0x6auy; 0x0duy; 0x07uy; 0x2buy; 0x04uy; 0xb3uy; 0x56uy; 0x4euy; 0xeauy; 0x1buy; 0x42uy; 0x22uy; 0x73uy; 0xf5uy; 0x48uy; 0x27uy; 0x1auy; 0x0buy; 0xb2uy; 0x31uy; 0x60uy; 0x53uy; 0xfauy; 0x76uy; 0x99uy; 0x19uy; 0x55uy; 0xebuy; 0xd6uy; 0x31uy; 0x59uy; 0x43uy; 0x4euy; 0xceuy; 0xbbuy; 0x4euy; 0x46uy; 0x6duy; 0xaeuy; 0x5auy; 0x10uy; 0x73uy; 0xa6uy; 0x72uy; 0x76uy; 0x27uy; 0x09uy; 0x7auy; 0x10uy; 0x49uy; 0xe6uy; 0x17uy; 0xd9uy; 0x1duy; 0x36uy; 0x10uy; 0x94uy; 0xfauy; 0x68uy; 0xf0uy; 0xffuy; 0x77uy; 0x98uy; 0x71uy; 0x30uy; 0x30uy; 0x5buy; 0xeauy; 0xbauy; 0x2euy; 0xdauy; 0x04uy; 0xdfuy; 0x99uy; 0x7buy; 0x71uy; 0x4duy; 0x6cuy; 0x6fuy; 0x2cuy; 0x29uy; 0xa6uy; 0xaduy; 0x5cuy; 0xb4uy; 0x02uy; 0x2buy; 0x02uy; 0x70uy; 0x9buy; 0xeeuy; 0xaduy; 0x9duy; 0x67uy; 0x89uy; 0x0cuy; 0xbbuy; 0x22uy; 0x39uy; 0x23uy; 0x36uy; 0xfeuy; 0xa1uy; 0x85uy; 0x1fuy; 0x38uy; ] in
assert_norm (List.Tot.length l = 281);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let output0_len: (x:UInt32.t { UInt32.v x = B.length output0 }) =
281ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x4cuy; 0xf5uy; 0x96uy; 0x83uy; 0x38uy; 0xe6uy; 0xaeuy; 0x7fuy; 0x2duy; 0x29uy; 0x25uy; 0x76uy; 0xd5uy; 0x75uy; 0x27uy; 0x86uy; 0x91uy; 0x9auy; 0x27uy; 0x7auy; 0xfbuy; 0x46uy; 0xc5uy; 0xefuy; 0x94uy; 0x81uy; 0x79uy; 0x57uy; 0x14uy; 0x59uy; 0x40uy; 0x68uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let nonce1: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xcauy; 0xbfuy; 0x33uy; 0x71uy; 0x32uy; 0x45uy; 0x77uy; 0x8euy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce1_len: (x:UInt32.t { UInt32.v x = B.length nonce1 }) =
12ul
let aad1: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad1_len: (x:UInt32.t { UInt32.v x = B.length aad1 }) =
0ul
let input1: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b /\ B.disjoint b aad1 }) =
B.recall aad1;[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
0ul
let output1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xeauy; 0xe0uy; 0x1euy; 0x9euy; 0x2cuy; 0x91uy; 0xaauy; 0xe1uy; 0xdbuy; 0x5duy; 0x99uy; 0x3fuy; 0x8auy; 0xf7uy; 0x69uy; 0x92uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let output1_len: (x:UInt32.t { UInt32.v x = B.length output1 }) =
16ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x2duy; 0xb0uy; 0x5duy; 0x40uy; 0xc8uy; 0xeduy; 0x44uy; 0x88uy; 0x34uy; 0xd1uy; 0x13uy; 0xafuy; 0x57uy; 0xa1uy; 0xebuy; 0x3auy; 0x2auy; 0x80uy; 0x51uy; 0x36uy; 0xecuy; 0x5buy; 0xbcuy; 0x08uy; 0x93uy; 0x84uy; 0x21uy; 0xb5uy; 0x13uy; 0x88uy; 0x3cuy; 0x0duy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let nonce2: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x3duy; 0x86uy; 0xb5uy; 0x6buy; 0xc8uy; 0xa3uy; 0x1fuy; 0x1duy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce2_len: (x:UInt32.t { UInt32.v x = B.length nonce2 }) =
12ul
let aad2: (b: B.buffer UInt8.t { B.length b = 8 /\ B.recallable b }) =
[@inline_let] let l = [ 0x33uy; 0x10uy; 0x41uy; 0x12uy; 0x1fuy; 0xf3uy; 0xd2uy; 0x6buy; ] in
assert_norm (List.Tot.length l = 8);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad2_len: (x:UInt32.t { UInt32.v x = B.length aad2 }) =
8ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b /\ B.disjoint b aad2 }) =
B.recall aad2;[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let output2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x6buy; 0x3buy; 0x82uy; 0xceuy; 0x5auy; 0xbduy; 0xd6uy; 0xa9uy; 0x35uy; 0x83uy; 0xd8uy; 0x8cuy; 0x3duy; 0x85uy; 0x77uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let output2_len: (x:UInt32.t { UInt32.v x = B.length output2 }) =
16ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x4buy; 0x28uy; 0x4buy; 0xa3uy; 0x7buy; 0xbeuy; 0xe9uy; 0xf8uy; 0x31uy; 0x80uy; 0x82uy; 0xd7uy; 0xd8uy; 0xe8uy; 0xb5uy; 0xa1uy; 0xe2uy; 0x18uy; 0x18uy; 0x8auy; 0x9cuy; 0xfauy; 0xa3uy; 0x3duy; 0x25uy; 0x71uy; 0x3euy; 0x40uy; 0xbcuy; 0x54uy; 0x7auy; 0x3euy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let nonce3: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xd2uy; 0x32uy; 0x1fuy; 0x29uy; 0x28uy; 0xc6uy; 0xc4uy; 0xc4uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce3_len: (x:UInt32.t { UInt32.v x = B.length nonce3 }) =
12ul
let aad3: (b: B.buffer UInt8.t { B.length b = 8 /\ B.recallable b }) =
[@inline_let] let l = [ 0x6auy; 0xe2uy; 0xaduy; 0x3fuy; 0x88uy; 0x39uy; 0x5auy; 0x40uy; ] in
assert_norm (List.Tot.length l = 8);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad3_len: (x:UInt32.t { UInt32.v x = B.length aad3 }) =
8ul
let input3: (b: B.buffer UInt8.t { B.length b = 1 /\ B.recallable b /\ B.disjoint b aad3 }) =
B.recall aad3;[@inline_let] let l = [ 0xa4uy; ] in
assert_norm (List.Tot.length l = 1);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
1ul
let output3: (b: B.buffer UInt8.t { B.length b = 17 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb7uy; 0x1buy; 0xb0uy; 0x73uy; 0x59uy; 0xb0uy; 0x84uy; 0xb2uy; 0x6duy; 0x8euy; 0xabuy; 0x94uy; 0x31uy; 0xa1uy; 0xaeuy; 0xacuy; 0x89uy; ] in
assert_norm (List.Tot.length l = 17);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let output3_len: (x:UInt32.t { UInt32.v x = B.length output3 }) =
17ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0xcauy; 0x9cuy; 0x23uy; 0x2auy; 0x4buy; 0x4buy; 0x31uy; 0x0euy; 0x92uy; 0x89uy; 0x8buy; 0xf4uy; 0x93uy; 0xc7uy; 0x87uy; 0x98uy; 0xa3uy; 0xd8uy; 0x39uy; 0xf8uy; 0xf4uy; 0xa7uy; 0x01uy; 0xc0uy; 0x2euy; 0x0auy; 0xa6uy; 0x7euy; 0x5auy; 0x78uy; 0x87uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let nonce4: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x1cuy; 0xaauy; 0x5fuy; 0x9cuy; 0xbfuy; 0x92uy; 0x30uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce4_len: (x:UInt32.t { UInt32.v x = B.length nonce4 }) =
12ul
let aad4: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad4_len: (x:UInt32.t { UInt32.v x = B.length aad4 }) =
0ul
let input4: (b: B.buffer UInt8.t { B.length b = 1 /\ B.recallable b /\ B.disjoint b aad4 }) =
B.recall aad4;[@inline_let] let l = [ 0x2duy; ] in
assert_norm (List.Tot.length l = 1);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
1ul
let output4: (b: B.buffer UInt8.t { B.length b = 17 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbfuy; 0xe1uy; 0x5buy; 0x0buy; 0xdbuy; 0x6buy; 0xf5uy; 0x5euy; 0x6cuy; 0x5duy; 0x84uy; 0x44uy; 0x39uy; 0x81uy; 0xc1uy; 0x9cuy; 0xacuy; ] in
assert_norm (List.Tot.length l = 17);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let output4_len: (x:UInt32.t { UInt32.v x = B.length output4 }) =
17ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x68uy; 0x7buy; 0x8duy; 0x8euy; 0xe3uy; 0xc4uy; 0xdduy; 0xaeuy; 0xdfuy; 0x72uy; 0x7fuy; 0x53uy; 0x72uy; 0x25uy; 0x1euy; 0x78uy; 0x91uy; 0xcbuy; 0x69uy; 0x76uy; 0x1fuy; 0x49uy; 0x93uy; 0xf9uy; 0x6fuy; 0x21uy; 0xccuy; 0x39uy; 0x9cuy; 0xaduy; 0xb1uy; 0x01uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let nonce5: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xdfuy; 0x51uy; 0x84uy; 0x82uy; 0x42uy; 0x0cuy; 0x75uy; 0x9cuy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce5_len: (x:UInt32.t { UInt32.v x = B.length nonce5 }) =
12ul
let aad5: (b: B.buffer UInt8.t { B.length b = 7 /\ B.recallable b }) =
[@inline_let] let l = [ 0x70uy; 0xd3uy; 0x33uy; 0xf3uy; 0x8buy; 0x18uy; 0x0buy; ] in
assert_norm (List.Tot.length l = 7);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad5_len: (x:UInt32.t { UInt32.v x = B.length aad5 }) =
7ul
let input5: (b: B.buffer UInt8.t { B.length b = 129 /\ B.recallable b /\ B.disjoint b aad5 }) =
B.recall aad5;[@inline_let] let l = [ 0x33uy; 0x2fuy; 0x94uy; 0xc1uy; 0xa4uy; 0xefuy; 0xccuy; 0x2auy; 0x5buy; 0xa6uy; 0xe5uy; 0x8fuy; 0x1duy; 0x40uy; 0xf0uy; 0x92uy; 0x3cuy; 0xd9uy; 0x24uy; 0x11uy; 0xa9uy; 0x71uy; 0xf9uy; 0x37uy; 0x14uy; 0x99uy; 0xfauy; 0xbeuy; 0xe6uy; 0x80uy; 0xdeuy; 0x50uy; 0xc9uy; 0x96uy; 0xd4uy; 0xb0uy; 0xecuy; 0x9euy; 0x17uy; 0xecuy; 0xd2uy; 0x5euy; 0x72uy; 0x99uy; 0xfcuy; 0x0auy; 0xe1uy; 0xcbuy; 0x48uy; 0xd2uy; 0x85uy; 0xdduy; 0x2fuy; 0x90uy; 0xe0uy; 0x66uy; 0x3buy; 0xe6uy; 0x20uy; 0x74uy; 0xbeuy; 0x23uy; 0x8fuy; 0xcbuy; 0xb4uy; 0xe4uy; 0xdauy; 0x48uy; 0x40uy; 0xa6uy; 0xd1uy; 0x1buy; 0xc7uy; 0x42uy; 0xceuy; 0x2fuy; 0x0cuy; 0xa6uy; 0x85uy; 0x6euy; 0x87uy; 0x37uy; 0x03uy; 0xb1uy; 0x7cuy; 0x25uy; 0x96uy; 0xa3uy; 0x05uy; 0xd8uy; 0xb0uy; 0xf4uy; 0xeduy; 0xeauy; 0xc2uy; 0xf0uy; 0x31uy; 0x98uy; 0x6cuy; 0xd1uy; 0x14uy; 0x25uy; 0xc0uy; 0xcbuy; 0x01uy; 0x74uy; 0xd0uy; 0x82uy; 0xf4uy; 0x36uy; 0xf5uy; 0x41uy; 0xd5uy; 0xdcuy; 0xcauy; 0xc5uy; 0xbbuy; 0x98uy; 0xfeuy; 0xfcuy; 0x69uy; 0x21uy; 0x70uy; 0xd8uy; 0xa4uy; 0x4buy; 0xc8uy; 0xdeuy; 0x8fuy; ] in
assert_norm (List.Tot.length l = 129);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
129ul
let output5: (b: B.buffer UInt8.t { B.length b = 145 /\ B.recallable b }) =
[@inline_let] let l = [ 0x8buy; 0x06uy; 0xd3uy; 0x31uy; 0xb0uy; 0x93uy; 0x45uy; 0xb1uy; 0x75uy; 0x6euy; 0x26uy; 0xf9uy; 0x67uy; 0xbcuy; 0x90uy; 0x15uy; 0x81uy; 0x2cuy; 0xb5uy; 0xf0uy; 0xc6uy; 0x2buy; 0xc7uy; 0x8cuy; 0x56uy; 0xd1uy; 0xbfuy; 0x69uy; 0x6cuy; 0x07uy; 0xa0uy; 0xdauy; 0x65uy; 0x27uy; 0xc9uy; 0x90uy; 0x3duy; 0xefuy; 0x4buy; 0x11uy; 0x0fuy; 0x19uy; 0x07uy; 0xfduy; 0x29uy; 0x92uy; 0xd9uy; 0xc8uy; 0xf7uy; 0x99uy; 0x2euy; 0x4auy; 0xd0uy; 0xb8uy; 0x2cuy; 0xdcuy; 0x93uy; 0xf5uy; 0x9euy; 0x33uy; 0x78uy; 0xd1uy; 0x37uy; 0xc3uy; 0x66uy; 0xd7uy; 0x5euy; 0xbcuy; 0x44uy; 0xbfuy; 0x53uy; 0xa5uy; 0xbcuy; 0xc4uy; 0xcbuy; 0x7buy; 0x3auy; 0x8euy; 0x7fuy; 0x02uy; 0xbduy; 0xbbuy; 0xe7uy; 0xcauy; 0xa6uy; 0x6cuy; 0x6buy; 0x93uy; 0x21uy; 0x93uy; 0x10uy; 0x61uy; 0xe7uy; 0x69uy; 0xd0uy; 0x78uy; 0xf3uy; 0x07uy; 0x5auy; 0x1auy; 0x8fuy; 0x73uy; 0xaauy; 0xb1uy; 0x4euy; 0xd3uy; 0xdauy; 0x4fuy; 0xf3uy; 0x32uy; 0xe1uy; 0x66uy; 0x3euy; 0x6cuy; 0xc6uy; 0x13uy; 0xbauy; 0x06uy; 0x5buy; 0xfcuy; 0x6auy; 0xe5uy; 0x6fuy; 0x60uy; 0xfbuy; 0x07uy; 0x40uy; 0xb0uy; 0x8cuy; 0x9duy; 0x84uy; 0x43uy; 0x6buy; 0xc1uy; 0xf7uy; 0x8duy; 0x8duy; 0x31uy; 0xf7uy; 0x7auy; 0x39uy; 0x4duy; 0x8fuy; 0x9auy; 0xebuy; ] in
assert_norm (List.Tot.length l = 145);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let output5_len: (x:UInt32.t { UInt32.v x = B.length output5 }) =
145ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x8duy; 0xb8uy; 0x91uy; 0x48uy; 0xf0uy; 0xe7uy; 0x0auy; 0xbduy; 0xf9uy; 0x3fuy; 0xcduy; 0xd9uy; 0xa0uy; 0x1euy; 0x42uy; 0x4cuy; 0xe7uy; 0xdeuy; 0x25uy; 0x3duy; 0xa3uy; 0xd7uy; 0x05uy; 0x80uy; 0x8duy; 0xf2uy; 0x82uy; 0xacuy; 0x44uy; 0x16uy; 0x51uy; 0x01uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let nonce6: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xdeuy; 0x7buy; 0xefuy; 0xc3uy; 0x65uy; 0x1buy; 0x68uy; 0xb0uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce6_len: (x:UInt32.t { UInt32.v x = B.length nonce6 }) =
12ul
let aad6: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad6_len: (x:UInt32.t { UInt32.v x = B.length aad6 }) =
0ul
let input6: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b /\ B.disjoint b aad6 }) =
B.recall aad6;[@inline_let] let l = [ 0x9buy; 0x18uy; 0xdbuy; 0xdduy; 0x9auy; 0x0fuy; 0x3euy; 0xa5uy; 0x15uy; 0x17uy; 0xdeuy; 0xdfuy; 0x08uy; 0x9duy; 0x65uy; 0x0auy; 0x67uy; 0x30uy; 0x12uy; 0xe2uy; 0x34uy; 0x77uy; 0x4buy; 0xc1uy; 0xd9uy; 0xc6uy; 0x1fuy; 0xabuy; 0xc6uy; 0x18uy; 0x50uy; 0x17uy; 0xa7uy; 0x9duy; 0x3cuy; 0xa6uy; 0xc5uy; 0x35uy; 0x8cuy; 0x1cuy; 0xc0uy; 0xa1uy; 0x7cuy; 0x9fuy; 0x03uy; 0x89uy; 0xcauy; 0xe1uy; 0xe6uy; 0xe9uy; 0xd4uy; 0xd3uy; 0x88uy; 0xdbuy; 0xb4uy; 0x51uy; 0x9duy; 0xecuy; 0xb4uy; 0xfcuy; 0x52uy; 0xeeuy; 0x6duy; 0xf1uy; 0x75uy; 0x42uy; 0xc6uy; 0xfduy; 0xbduy; 0x7auy; 0x8euy; 0x86uy; 0xfcuy; 0x44uy; 0xb3uy; 0x4fuy; 0xf3uy; 0xeauy; 0x67uy; 0x5auy; 0x41uy; 0x13uy; 0xbauy; 0xb0uy; 0xdcuy; 0xe1uy; 0xd3uy; 0x2auy; 0x7cuy; 0x22uy; 0xb3uy; 0xcauy; 0xacuy; 0x6auy; 0x37uy; 0x98uy; 0x3euy; 0x1duy; 0x40uy; 0x97uy; 0xf7uy; 0x9buy; 0x1duy; 0x36uy; 0x6buy; 0xb3uy; 0x28uy; 0xbduy; 0x60uy; 0x82uy; 0x47uy; 0x34uy; 0xaauy; 0x2fuy; 0x7duy; 0xe9uy; 0xa8uy; 0x70uy; 0x81uy; 0x57uy; 0xd4uy; 0xb9uy; 0x77uy; 0x0auy; 0x9duy; 0x29uy; 0xa7uy; 0x84uy; 0x52uy; 0x4fuy; 0xc2uy; 0x4auy; 0x40uy; 0x3buy; 0x3cuy; 0xd4uy; 0xc9uy; 0x2auy; 0xdbuy; 0x4auy; 0x53uy; 0xc4uy; 0xbeuy; 0x80uy; 0xe9uy; 0x51uy; 0x7fuy; 0x8fuy; 0xc7uy; 0xa2uy; 0xceuy; 0x82uy; 0x5cuy; 0x91uy; 0x1euy; 0x74uy; 0xd9uy; 0xd0uy; 0xbduy; 0xd5uy; 0xf3uy; 0xfduy; 0xdauy; 0x4duy; 0x25uy; 0xb4uy; 0xbbuy; 0x2duy; 0xacuy; 0x2fuy; 0x3duy; 0x71uy; 0x85uy; 0x7buy; 0xcfuy; 0x3cuy; 0x7buy; 0x3euy; 0x0euy; 0x22uy; 0x78uy; 0x0cuy; 0x29uy; 0xbfuy; 0xe4uy; 0xf4uy; 0x57uy; 0xb3uy; 0xcbuy; 0x49uy; 0xa0uy; 0xfcuy; 0x1euy; 0x05uy; 0x4euy; 0x16uy; 0xbcuy; 0xd5uy; 0xa8uy; 0xa3uy; 0xeeuy; 0x05uy; 0x35uy; 0xc6uy; 0x7cuy; 0xabuy; 0x60uy; 0x14uy; 0x55uy; 0x1auy; 0x8euy; 0xc5uy; 0x88uy; 0x5duy; 0xd5uy; 0x81uy; 0xc2uy; 0x81uy; 0xa5uy; 0xc4uy; 0x60uy; 0xdbuy; 0xafuy; 0x77uy; 0x91uy; 0xe1uy; 0xceuy; 0xa2uy; 0x7euy; 0x7fuy; 0x42uy; 0xe3uy; 0xb0uy; 0x13uy; 0x1cuy; 0x1fuy; 0x25uy; 0x60uy; 0x21uy; 0xe2uy; 0x40uy; 0x5fuy; 0x99uy; 0xb7uy; 0x73uy; 0xecuy; 0x9buy; 0x2buy; 0xf0uy; 0x65uy; 0x11uy; 0xc8uy; 0xd0uy; 0x0auy; 0x9fuy; 0xd3uy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
256ul
let output6: (b: B.buffer UInt8.t { B.length b = 272 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x04uy; 0xc2uy; 0xeduy; 0x8duy; 0xfduy; 0x97uy; 0x5cuy; 0xd2uy; 0xb7uy; 0xe2uy; 0xc1uy; 0x6buy; 0xa3uy; 0xbauy; 0xf8uy; 0xc9uy; 0x50uy; 0xc3uy; 0xc6uy; 0xa5uy; 0xe3uy; 0xa4uy; 0x7cuy; 0xc3uy; 0x23uy; 0x49uy; 0x5euy; 0xa9uy; 0xb9uy; 0x32uy; 0xebuy; 0x8auy; 0x7cuy; 0xcauy; 0xe5uy; 0xecuy; 0xfbuy; 0x7cuy; 0xc0uy; 0xcbuy; 0x7duy; 0xdcuy; 0x2cuy; 0x9duy; 0x92uy; 0x55uy; 0x21uy; 0x0auy; 0xc8uy; 0x43uy; 0x63uy; 0x59uy; 0x0auy; 0x31uy; 0x70uy; 0x82uy; 0x67uy; 0x41uy; 0x03uy; 0xf8uy; 0xdfuy; 0xf2uy; 0xacuy; 0xa7uy; 0x02uy; 0xd4uy; 0xd5uy; 0x8auy; 0x2duy; 0xc8uy; 0x99uy; 0x19uy; 0x66uy; 0xd0uy; 0xf6uy; 0x88uy; 0x2cuy; 0x77uy; 0xd9uy; 0xd4uy; 0x0duy; 0x6cuy; 0xbduy; 0x98uy; 0xdeuy; 0xe7uy; 0x7fuy; 0xaduy; 0x7euy; 0x8auy; 0xfbuy; 0xe9uy; 0x4buy; 0xe5uy; 0xf7uy; 0xe5uy; 0x50uy; 0xa0uy; 0x90uy; 0x3fuy; 0xd6uy; 0x22uy; 0x53uy; 0xe3uy; 0xfeuy; 0x1buy; 0xccuy; 0x79uy; 0x3buy; 0xecuy; 0x12uy; 0x47uy; 0x52uy; 0xa7uy; 0xd6uy; 0x04uy; 0xe3uy; 0x52uy; 0xe6uy; 0x93uy; 0x90uy; 0x91uy; 0x32uy; 0x73uy; 0x79uy; 0xb8uy; 0xd0uy; 0x31uy; 0xdeuy; 0x1fuy; 0x9fuy; 0x2fuy; 0x05uy; 0x38uy; 0x54uy; 0x2fuy; 0x35uy; 0x04uy; 0x39uy; 0xe0uy; 0xa7uy; 0xbauy; 0xc6uy; 0x52uy; 0xf6uy; 0x37uy; 0x65uy; 0x4cuy; 0x07uy; 0xa9uy; 0x7euy; 0xb3uy; 0x21uy; 0x6fuy; 0x74uy; 0x8cuy; 0xc9uy; 0xdeuy; 0xdbuy; 0x65uy; 0x1buy; 0x9buy; 0xaauy; 0x60uy; 0xb1uy; 0x03uy; 0x30uy; 0x6buy; 0xb2uy; 0x03uy; 0xc4uy; 0x1cuy; 0x04uy; 0xf8uy; 0x0fuy; 0x64uy; 0xafuy; 0x46uy; 0xe4uy; 0x65uy; 0x99uy; 0x49uy; 0xe2uy; 0xeauy; 0xceuy; 0x78uy; 0x00uy; 0xd8uy; 0x8buy; 0xd5uy; 0x2euy; 0xcfuy; 0xfcuy; 0x40uy; 0x49uy; 0xe8uy; 0x58uy; 0xdcuy; 0x34uy; 0x9cuy; 0x8cuy; 0x61uy; 0xbfuy; 0x0auy; 0x8euy; 0xecuy; 0x39uy; 0xa9uy; 0x30uy; 0x05uy; 0x5auy; 0xd2uy; 0x56uy; 0x01uy; 0xc7uy; 0xdauy; 0x8fuy; 0x4euy; 0xbbuy; 0x43uy; 0xa3uy; 0x3auy; 0xf9uy; 0x15uy; 0x2auy; 0xd0uy; 0xa0uy; 0x7auy; 0x87uy; 0x34uy; 0x82uy; 0xfeuy; 0x8auy; 0xd1uy; 0x2duy; 0x5euy; 0xc7uy; 0xbfuy; 0x04uy; 0x53uy; 0x5fuy; 0x3buy; 0x36uy; 0xd4uy; 0x25uy; 0x5cuy; 0x34uy; 0x7auy; 0x8duy; 0xd5uy; 0x05uy; 0xceuy; 0x72uy; 0xcauy; 0xefuy; 0x7auy; 0x4buy; 0xbcuy; 0xb0uy; 0x10uy; 0x5cuy; 0x96uy; 0x42uy; 0x3auy; 0x00uy; 0x98uy; 0xcduy; 0x15uy; 0xe8uy; 0xb7uy; 0x53uy; ] in
assert_norm (List.Tot.length l = 272);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let output6_len: (x:UInt32.t { UInt32.v x = B.length output6 }) =
272ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0xaauy; 0x4fuy; 0x99uy; 0xfduy; 0x3euy; 0xa8uy; 0x53uy; 0xc1uy; 0x44uy; 0xe9uy; 0x81uy; 0x18uy; 0xdcuy; 0xf5uy; 0xf0uy; 0x3euy; 0x44uy; 0x15uy; 0x59uy; 0xe0uy; 0xc5uy; 0x44uy; 0x86uy; 0xc3uy; 0x91uy; 0xa8uy; 0x75uy; 0xc0uy; 0x12uy; 0x46uy; 0xbauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let nonce7: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x0euy; 0x0duy; 0x57uy; 0xbbuy; 0x7buy; 0x40uy; 0x54uy; 0x02uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce7_len: (x:UInt32.t { UInt32.v x = B.length nonce7 }) =
12ul
let aad7: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad7_len: (x:UInt32.t { UInt32.v x = B.length aad7 }) =
0ul
let input7: (b: B.buffer UInt8.t { B.length b = 512 /\ B.recallable b /\ B.disjoint b aad7 }) =
B.recall aad7;[@inline_let] let l = [ 0xc3uy; 0x09uy; 0x94uy; 0x62uy; 0xe6uy; 0x46uy; 0x2euy; 0x10uy; 0xbeuy; 0x00uy; 0xe4uy; 0xfcuy; 0xf3uy; 0x40uy; 0xa3uy; 0xe2uy; 0x0fuy; 0xc2uy; 0x8buy; 0x28uy; 0xdcuy; 0xbauy; 0xb4uy; 0x3cuy; 0xe4uy; 0x21uy; 0x58uy; 0x61uy; 0xcduy; 0x8buy; 0xcduy; 0xfbuy; 0xacuy; 0x94uy; 0xa1uy; 0x45uy; 0xf5uy; 0x1cuy; 0xe1uy; 0x12uy; 0xe0uy; 0x3buy; 0x67uy; 0x21uy; 0x54uy; 0x5euy; 0x8cuy; 0xaauy; 0xcfuy; 0xdbuy; 0xb4uy; 0x51uy; 0xd4uy; 0x13uy; 0xdauy; 0xe6uy; 0x83uy; 0x89uy; 0xb6uy; 0x92uy; 0xe9uy; 0x21uy; 0x76uy; 0xa4uy; 0x93uy; 0x7duy; 0x0euy; 0xfduy; 0x96uy; 0x36uy; 0x03uy; 0x91uy; 0x43uy; 0x5cuy; 0x92uy; 0x49uy; 0x62uy; 0x61uy; 0x7buy; 0xebuy; 0x43uy; 0x89uy; 0xb8uy; 0x12uy; 0x20uy; 0x43uy; 0xd4uy; 0x47uy; 0x06uy; 0x84uy; 0xeeuy; 0x47uy; 0xe9uy; 0x8auy; 0x73uy; 0x15uy; 0x0fuy; 0x72uy; 0xcfuy; 0xeduy; 0xceuy; 0x96uy; 0xb2uy; 0x7fuy; 0x21uy; 0x45uy; 0x76uy; 0xebuy; 0x26uy; 0x28uy; 0x83uy; 0x6auy; 0xaduy; 0xaauy; 0xa6uy; 0x81uy; 0xd8uy; 0x55uy; 0xb1uy; 0xa3uy; 0x85uy; 0xb3uy; 0x0cuy; 0xdfuy; 0xf1uy; 0x69uy; 0x2duy; 0x97uy; 0x05uy; 0x2auy; 0xbcuy; 0x7cuy; 0x7buy; 0x25uy; 0xf8uy; 0x80uy; 0x9duy; 0x39uy; 0x25uy; 0xf3uy; 0x62uy; 0xf0uy; 0x66uy; 0x5euy; 0xf4uy; 0xa0uy; 0xcfuy; 0xd8uy; 0xfduy; 0x4fuy; 0xb1uy; 0x1fuy; 0x60uy; 0x3auy; 0x08uy; 0x47uy; 0xafuy; 0xe1uy; 0xf6uy; 0x10uy; 0x77uy; 0x09uy; 0xa7uy; 0x27uy; 0x8fuy; 0x9auy; 0x97uy; 0x5auy; 0x26uy; 0xfauy; 0xfeuy; 0x41uy; 0x32uy; 0x83uy; 0x10uy; 0xe0uy; 0x1duy; 0xbfuy; 0x64uy; 0x0duy; 0xf4uy; 0x1cuy; 0x32uy; 0x35uy; 0xe5uy; 0x1buy; 0x36uy; 0xefuy; 0xd4uy; 0x4auy; 0x93uy; 0x4duy; 0x00uy; 0x7cuy; 0xecuy; 0x02uy; 0x07uy; 0x8buy; 0x5duy; 0x7duy; 0x1buy; 0x0euy; 0xd1uy; 0xa6uy; 0xa5uy; 0x5duy; 0x7duy; 0x57uy; 0x88uy; 0xa8uy; 0xccuy; 0x81uy; 0xb4uy; 0x86uy; 0x4euy; 0xb4uy; 0x40uy; 0xe9uy; 0x1duy; 0xc3uy; 0xb1uy; 0x24uy; 0x3euy; 0x7fuy; 0xccuy; 0x8auy; 0x24uy; 0x9buy; 0xdfuy; 0x6duy; 0xf0uy; 0x39uy; 0x69uy; 0x3euy; 0x4cuy; 0xc0uy; 0x96uy; 0xe4uy; 0x13uy; 0xdauy; 0x90uy; 0xdauy; 0xf4uy; 0x95uy; 0x66uy; 0x8buy; 0x17uy; 0x17uy; 0xfeuy; 0x39uy; 0x43uy; 0x25uy; 0xaauy; 0xdauy; 0xa0uy; 0x43uy; 0x3cuy; 0xb1uy; 0x41uy; 0x02uy; 0xa3uy; 0xf0uy; 0xa7uy; 0x19uy; 0x59uy; 0xbcuy; 0x1duy; 0x7duy; 0x6cuy; 0x6duy; 0x91uy; 0x09uy; 0x5cuy; 0xb7uy; 0x5buy; 0x01uy; 0xd1uy; 0x6fuy; 0x17uy; 0x21uy; 0x97uy; 0xbfuy; 0x89uy; 0x71uy; 0xa5uy; 0xb0uy; 0x6euy; 0x07uy; 0x45uy; 0xfduy; 0x9duy; 0xeauy; 0x07uy; 0xf6uy; 0x7auy; 0x9fuy; 0x10uy; 0x18uy; 0x22uy; 0x30uy; 0x73uy; 0xacuy; 0xd4uy; 0x6buy; 0x72uy; 0x44uy; 0xeduy; 0xd9uy; 0x19uy; 0x9buy; 0x2duy; 0x4auy; 0x41uy; 0xdduy; 0xd1uy; 0x85uy; 0x5euy; 0x37uy; 0x19uy; 0xeduy; 0xd2uy; 0x15uy; 0x8fuy; 0x5euy; 0x91uy; 0xdbuy; 0x33uy; 0xf2uy; 0xe4uy; 0xdbuy; 0xffuy; 0x98uy; 0xfbuy; 0xa3uy; 0xb5uy; 0xcauy; 0x21uy; 0x69uy; 0x08uy; 0xe7uy; 0x8auy; 0xdfuy; 0x90uy; 0xffuy; 0x3euy; 0xe9uy; 0x20uy; 0x86uy; 0x3cuy; 0xe9uy; 0xfcuy; 0x0buy; 0xfeuy; 0x5cuy; 0x61uy; 0xaauy; 0x13uy; 0x92uy; 0x7fuy; 0x7buy; 0xecuy; 0xe0uy; 0x6duy; 0xa8uy; 0x23uy; 0x22uy; 0xf6uy; 0x6buy; 0x77uy; 0xc4uy; 0xfeuy; 0x40uy; 0x07uy; 0x3buy; 0xb6uy; 0xf6uy; 0x8euy; 0x5fuy; 0xd4uy; 0xb9uy; 0xb7uy; 0x0fuy; 0x21uy; 0x04uy; 0xefuy; 0x83uy; 0x63uy; 0x91uy; 0x69uy; 0x40uy; 0xa3uy; 0x48uy; 0x5cuy; 0xd2uy; 0x60uy; 0xf9uy; 0x4fuy; 0x6cuy; 0x47uy; 0x8buy; 0x3buy; 0xb1uy; 0x9fuy; 0x8euy; 0xeeuy; 0x16uy; 0x8auy; 0x13uy; 0xfcuy; 0x46uy; 0x17uy; 0xc3uy; 0xc3uy; 0x32uy; 0x56uy; 0xf8uy; 0x3cuy; 0x85uy; 0x3auy; 0xb6uy; 0x3euy; 0xaauy; 0x89uy; 0x4fuy; 0xb3uy; 0xdfuy; 0x38uy; 0xfduy; 0xf1uy; 0xe4uy; 0x3auy; 0xc0uy; 0xe6uy; 0x58uy; 0xb5uy; 0x8fuy; 0xc5uy; 0x29uy; 0xa2uy; 0x92uy; 0x4auy; 0xb6uy; 0xa0uy; 0x34uy; 0x7fuy; 0xabuy; 0xb5uy; 0x8auy; 0x90uy; 0xa1uy; 0xdbuy; 0x4duy; 0xcauy; 0xb6uy; 0x2cuy; 0x41uy; 0x3cuy; 0xf7uy; 0x2buy; 0x21uy; 0xc3uy; 0xfduy; 0xf4uy; 0x17uy; 0x5cuy; 0xb5uy; 0x33uy; 0x17uy; 0x68uy; 0x2buy; 0x08uy; 0x30uy; 0xf3uy; 0xf7uy; 0x30uy; 0x3cuy; 0x96uy; 0xe6uy; 0x6auy; 0x20uy; 0x97uy; 0xe7uy; 0x4duy; 0x10uy; 0x5fuy; 0x47uy; 0x5fuy; 0x49uy; 0x96uy; 0x09uy; 0xf0uy; 0x27uy; 0x91uy; 0xc8uy; 0xf8uy; 0x5auy; 0x2euy; 0x79uy; 0xb5uy; 0xe2uy; 0xb8uy; 0xe8uy; 0xb9uy; 0x7buy; 0xd5uy; 0x10uy; 0xcbuy; 0xffuy; 0x5duy; 0x14uy; 0x73uy; 0xf3uy; ] in
assert_norm (List.Tot.length l = 512);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
512ul | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Chacha20Poly1305.fst"
} | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"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": 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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 528 /\ LowStar.Monotonic.Buffer.recallable b} | Prims.Tot | [
"total"
] | [] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | false | false | false | false | false | let output7:(b: B.buffer UInt8.t {B.length b = 528 /\ B.recallable b}) =
| [@@ inline_let ]let l =
[
0x14uy; 0xf6uy; 0x41uy; 0x37uy; 0xa6uy; 0xd4uy; 0x27uy; 0xcduy; 0xdbuy; 0x06uy; 0x3euy; 0x9auy;
0x4euy; 0xabuy; 0xd5uy; 0xb1uy; 0x1euy; 0x6buy; 0xd2uy; 0xbcuy; 0x11uy; 0xf4uy; 0x28uy; 0x93uy;
0x63uy; 0x54uy; 0xefuy; 0xbbuy; 0x5euy; 0x1duy; 0x3auy; 0x1duy; 0x37uy; 0x3cuy; 0x0auy; 0x6cuy;
0x1euy; 0xc2uy; 0xd1uy; 0x2cuy; 0xb5uy; 0xa3uy; 0xb5uy; 0x7buy; 0xb8uy; 0x8fuy; 0x25uy; 0xa6uy;
0x1buy; 0x61uy; 0x1cuy; 0xecuy; 0x28uy; 0x58uy; 0x26uy; 0xa4uy; 0xa8uy; 0x33uy; 0x28uy; 0x25uy;
0x5cuy; 0x45uy; 0x05uy; 0xe5uy; 0x6cuy; 0x99uy; 0xe5uy; 0x45uy; 0xc4uy; 0xa2uy; 0x03uy; 0x84uy;
0x03uy; 0x73uy; 0x1euy; 0x8cuy; 0x49uy; 0xacuy; 0x20uy; 0xdduy; 0x8duy; 0xb3uy; 0xc4uy; 0xf5uy;
0xe7uy; 0x4fuy; 0xf1uy; 0xeduy; 0xa1uy; 0x98uy; 0xdeuy; 0xa4uy; 0x96uy; 0xdduy; 0x2fuy; 0xabuy;
0xabuy; 0x97uy; 0xcfuy; 0x3euy; 0xd2uy; 0x9euy; 0xb8uy; 0x13uy; 0x07uy; 0x28uy; 0x29uy; 0x19uy;
0xafuy; 0xfduy; 0xf2uy; 0x49uy; 0x43uy; 0xeauy; 0x49uy; 0x26uy; 0x91uy; 0xc1uy; 0x07uy; 0xd6uy;
0xbbuy; 0x81uy; 0x75uy; 0x35uy; 0x0duy; 0x24uy; 0x7fuy; 0xc8uy; 0xdauy; 0xd4uy; 0xb7uy; 0xebuy;
0xe8uy; 0x5cuy; 0x09uy; 0xa2uy; 0x2fuy; 0xdcuy; 0x28uy; 0x7duy; 0x3auy; 0x03uy; 0xfauy; 0x94uy;
0xb5uy; 0x1duy; 0x17uy; 0x99uy; 0x36uy; 0xc3uy; 0x1cuy; 0x18uy; 0x34uy; 0xe3uy; 0x9fuy; 0xf5uy;
0x55uy; 0x7cuy; 0xb0uy; 0x60uy; 0x9duy; 0xffuy; 0xacuy; 0xd4uy; 0x61uy; 0xf2uy; 0xaduy; 0xf8uy;
0xceuy; 0xc7uy; 0xbeuy; 0x5cuy; 0xd2uy; 0x95uy; 0xa8uy; 0x4buy; 0x77uy; 0x13uy; 0x19uy; 0x59uy;
0x26uy; 0xc9uy; 0xb7uy; 0x8fuy; 0x6auy; 0xcbuy; 0x2duy; 0x37uy; 0x91uy; 0xeauy; 0x92uy; 0x9cuy;
0x94uy; 0x5buy; 0xdauy; 0x0buy; 0xceuy; 0xfeuy; 0x30uy; 0x20uy; 0xf8uy; 0x51uy; 0xaduy; 0xf2uy;
0xbeuy; 0xe7uy; 0xc7uy; 0xffuy; 0xb3uy; 0x33uy; 0x91uy; 0x6auy; 0xc9uy; 0x1auy; 0x41uy; 0xc9uy;
0x0fuy; 0xf3uy; 0x10uy; 0x0euy; 0xfduy; 0x53uy; 0xffuy; 0x6cuy; 0x16uy; 0x52uy; 0xd9uy; 0xf3uy;
0xf7uy; 0x98uy; 0x2euy; 0xc9uy; 0x07uy; 0x31uy; 0x2cuy; 0x0cuy; 0x72uy; 0xd7uy; 0xc5uy; 0xc6uy;
0x08uy; 0x2auy; 0x7buy; 0xdauy; 0xbduy; 0x7euy; 0x02uy; 0xeauy; 0x1auy; 0xbbuy; 0xf2uy; 0x04uy;
0x27uy; 0x61uy; 0x28uy; 0x8euy; 0xf5uy; 0x04uy; 0x03uy; 0x1fuy; 0x4cuy; 0x07uy; 0x55uy; 0x82uy;
0xecuy; 0x1euy; 0xd7uy; 0x8buy; 0x2fuy; 0x65uy; 0x56uy; 0xd1uy; 0xd9uy; 0x1euy; 0x3cuy; 0xe9uy;
0x1fuy; 0x5euy; 0x98uy; 0x70uy; 0x38uy; 0x4auy; 0x8cuy; 0x49uy; 0xc5uy; 0x43uy; 0xa0uy; 0xa1uy;
0x8buy; 0x74uy; 0x9duy; 0x4cuy; 0x62uy; 0x0duy; 0x10uy; 0x0cuy; 0xf4uy; 0x6cuy; 0x8fuy; 0xe0uy;
0xaauy; 0x9auy; 0x8duy; 0xb7uy; 0xe0uy; 0xbeuy; 0x4cuy; 0x87uy; 0xf1uy; 0x98uy; 0x2fuy; 0xccuy;
0xeduy; 0xc0uy; 0x52uy; 0x29uy; 0xdcuy; 0x83uy; 0xf8uy; 0xfcuy; 0x2cuy; 0x0euy; 0xa8uy; 0x51uy;
0x4duy; 0x80uy; 0x0duy; 0xa3uy; 0xfeuy; 0xd8uy; 0x37uy; 0xe7uy; 0x41uy; 0x24uy; 0xfcuy; 0xfbuy;
0x75uy; 0xe3uy; 0x71uy; 0x7buy; 0x57uy; 0x45uy; 0xf5uy; 0x97uy; 0x73uy; 0x65uy; 0x63uy; 0x14uy;
0x74uy; 0xb8uy; 0x82uy; 0x9fuy; 0xf8uy; 0x60uy; 0x2fuy; 0x8auy; 0xf2uy; 0x4euy; 0xf1uy; 0x39uy;
0xdauy; 0x33uy; 0x91uy; 0xf8uy; 0x36uy; 0xe0uy; 0x8duy; 0x3fuy; 0x1fuy; 0x3buy; 0x56uy; 0xdcuy;
0xa0uy; 0x8fuy; 0x3cuy; 0x9duy; 0x71uy; 0x52uy; 0xa7uy; 0xb8uy; 0xc0uy; 0xa5uy; 0xc6uy; 0xa2uy;
0x73uy; 0xdauy; 0xf4uy; 0x4buy; 0x74uy; 0x5buy; 0x00uy; 0x3duy; 0x99uy; 0xd7uy; 0x96uy; 0xbauy;
0xe6uy; 0xe1uy; 0xa6uy; 0x96uy; 0x38uy; 0xaduy; 0xb3uy; 0xc0uy; 0xd2uy; 0xbauy; 0x91uy; 0x6buy;
0xf9uy; 0x19uy; 0xdduy; 0x3buy; 0xbeuy; 0xbeuy; 0x9cuy; 0x20uy; 0x50uy; 0xbauy; 0xa1uy; 0xd0uy;
0xceuy; 0x11uy; 0xbduy; 0x95uy; 0xd8uy; 0xd1uy; 0xdduy; 0x33uy; 0x85uy; 0x74uy; 0xdcuy; 0xdbuy;
0x66uy; 0x76uy; 0x44uy; 0xdcuy; 0x03uy; 0x74uy; 0x48uy; 0x35uy; 0x98uy; 0xb1uy; 0x18uy; 0x47uy;
0x94uy; 0x7duy; 0xffuy; 0x62uy; 0xe4uy; 0x58uy; 0x78uy; 0xabuy; 0xeduy; 0x95uy; 0x36uy; 0xd9uy;
0x84uy; 0x91uy; 0x82uy; 0x64uy; 0x41uy; 0xbbuy; 0x58uy; 0xe6uy; 0x1cuy; 0x20uy; 0x6duy; 0x15uy;
0x6buy; 0x13uy; 0x96uy; 0xe8uy; 0x35uy; 0x7fuy; 0xdcuy; 0x40uy; 0x2cuy; 0xe9uy; 0xbcuy; 0x8auy;
0x4fuy; 0x92uy; 0xecuy; 0x06uy; 0x2duy; 0x50uy; 0xdfuy; 0x93uy; 0x5duy; 0x65uy; 0x5auy; 0xa8uy;
0xfcuy; 0x20uy; 0x50uy; 0x14uy; 0xa9uy; 0x8auy; 0x7euy; 0x1duy; 0x08uy; 0x1fuy; 0xe2uy; 0x99uy;
0xd0uy; 0xbeuy; 0xfbuy; 0x3auy; 0x21uy; 0x9duy; 0xaduy; 0x86uy; 0x54uy; 0xfduy; 0x0duy; 0x98uy;
0x1cuy; 0x5auy; 0x6fuy; 0x1fuy; 0x9auy; 0x40uy; 0xcduy; 0xa2uy; 0xffuy; 0x6auy; 0xf1uy; 0x54uy
]
in
assert_norm (List.Tot.length l = 528);
B.gcmalloc_of_list HyperStack.root l | false |
Spec.Frodo.Sample.fst | Spec.Frodo.Sample.frodo_sample | val frodo_sample: a:frodo_alg -> r:uint16 -> uint16 | val frodo_sample: a:frodo_alg -> r:uint16 -> uint16 | let frodo_sample a r =
let t = r >>. 1ul in
let r0 = r &. u16 1 in
mod_mask_lemma r 1ul;
assert (v #U16 #SEC (mod_mask 1ul) == 1);
assert (v r0 == 0 \/ v r0 == 1);
let e =
Loops.repeati_inductive
(cdf_table_len a - 1)
(fun z e -> 0 <= e /\ e <= z /\ e == frodo_sample_fc a t z)
(fun z e -> frodo_sample_f a t z + e) 0 in
frodo_sample_res a r0 e | {
"file_name": "specs/frodo/Spec.Frodo.Sample.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 25,
"end_line": 70,
"start_col": 0,
"start_line": 58
} | module Spec.Frodo.Sample
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
open Spec.Frodo.Lemmas
open Spec.Frodo.Params
module LSeq = Lib.Sequence
module Matrix = Spec.Matrix
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val frodo_sample_f:
a:frodo_alg
-> t:uint16
-> i:size_nat{i < cdf_table_len a}
-> res:nat{res = 0 \/ res = 1}
let frodo_sample_f a t i =
if v t > v (cdf_table a).[i] then 1 else 0
val frodo_sample_fc:
a:frodo_alg
-> t:uint16
-> i:size_nat{i <= cdf_table_len a}
-> GTot (res:nat{0 <= res /\ res <= i})
(decreases i)
let rec frodo_sample_fc a t i =
if i = 0 then 0
else frodo_sample_f a t (i - 1) + frodo_sample_fc a t (i - 1)
val frodo_sample_res:
a:frodo_alg
-> sign:uint16{v sign <= 1}
-> e:nat{e < cdf_table_len a}
-> uint16
let frodo_sample_res a r0 e =
let open FStar.Math.Lib in
let e = (powx (-1) (v r0)) * e in
assert_norm (powx (-1) 1 == -1);
assert_norm (powx (-1) 0 == 1);
assert (-cdf_table_len a < e /\ e < cdf_table_len a);
u16 (e % modulus U16)
#push-options "--fuel 1" | {
"checked_file": "/",
"dependencies": [
"Spec.Matrix.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.Lemmas.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Sample.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Spec.Matrix",
"short_module": "Matrix"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"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": 1,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Spec.Frodo.Params.frodo_alg -> r: Lib.IntTypes.uint16 -> Lib.IntTypes.uint16 | Prims.Tot | [
"total"
] | [] | [
"Spec.Frodo.Params.frodo_alg",
"Lib.IntTypes.uint16",
"Spec.Frodo.Sample.frodo_sample_res",
"Prims.int",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Spec.Frodo.Params.cdf_table_len",
"Prims.eq2",
"Spec.Frodo.Sample.frodo_sample_fc",
"Lib.LoopCombinators.repeati_inductive",
"Prims.nat",
"Prims.op_LessThan",
"Prims.op_Addition",
"Spec.Frodo.Sample.frodo_sample_f",
"Prims.unit",
"Prims._assert",
"Prims.l_or",
"Lib.IntTypes.v",
"Lib.IntTypes.U16",
"Lib.IntTypes.SEC",
"Lib.IntTypes.mod_mask",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.mod_mask_lemma",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Amp_Dot",
"Lib.IntTypes.u16",
"Lib.IntTypes.op_Greater_Greater_Dot"
] | [] | false | false | false | true | false | let frodo_sample a r =
| let t = r >>. 1ul in
let r0 = r &. u16 1 in
mod_mask_lemma r 1ul;
assert (v #U16 #SEC (mod_mask 1ul) == 1);
assert (v r0 == 0 \/ v r0 == 1);
let e =
Loops.repeati_inductive (cdf_table_len a - 1)
(fun z e -> 0 <= e /\ e <= z /\ e == frodo_sample_fc a t z)
(fun z e -> frodo_sample_f a t z + e)
0
in
frodo_sample_res a r0 e | false |
Test.Vectors.Chacha20Poly1305.fst | Test.Vectors.Chacha20Poly1305.output8 | val output8:(b: B.buffer UInt8.t {B.length b = 529 /\ B.recallable b}) | val output8:(b: B.buffer UInt8.t {B.length b = 529 /\ B.recallable b}) | let output8: (b: B.buffer UInt8.t { B.length b = 529 /\ B.recallable b }) =
[@inline_let] let l = [ 0xfduy; 0x81uy; 0x8duy; 0xd0uy; 0x3duy; 0xb4uy; 0xd5uy; 0xdfuy; 0xd3uy; 0x42uy; 0x47uy; 0x5auy; 0x6duy; 0x19uy; 0x27uy; 0x66uy; 0x4buy; 0x2euy; 0x0cuy; 0x27uy; 0x9cuy; 0x96uy; 0x4cuy; 0x72uy; 0x02uy; 0xa3uy; 0x65uy; 0xc3uy; 0xb3uy; 0x6fuy; 0x2euy; 0xbduy; 0x63uy; 0x8auy; 0x4auy; 0x5duy; 0x29uy; 0xa2uy; 0xd0uy; 0x28uy; 0x48uy; 0xc5uy; 0x3duy; 0x98uy; 0xa3uy; 0xbcuy; 0xe0uy; 0xbeuy; 0x3buy; 0x3fuy; 0xe6uy; 0x8auy; 0xa4uy; 0x7fuy; 0x53uy; 0x06uy; 0xfauy; 0x7fuy; 0x27uy; 0x76uy; 0x72uy; 0x31uy; 0xa1uy; 0xf5uy; 0xd6uy; 0x0cuy; 0x52uy; 0x47uy; 0xbauy; 0xcduy; 0x4fuy; 0xd7uy; 0xebuy; 0x05uy; 0x48uy; 0x0duy; 0x7cuy; 0x35uy; 0x4auy; 0x09uy; 0xc9uy; 0x76uy; 0x71uy; 0x02uy; 0xa3uy; 0xfbuy; 0xb7uy; 0x1auy; 0x65uy; 0xb7uy; 0xeduy; 0x98uy; 0xc6uy; 0x30uy; 0x8auy; 0x00uy; 0xaeuy; 0xa1uy; 0x31uy; 0xe5uy; 0xb5uy; 0x9euy; 0x6duy; 0x62uy; 0xdauy; 0xdauy; 0x07uy; 0x0fuy; 0x38uy; 0x38uy; 0xd3uy; 0xcbuy; 0xc1uy; 0xb0uy; 0xaduy; 0xecuy; 0x72uy; 0xecuy; 0xb1uy; 0xa2uy; 0x7buy; 0x59uy; 0xf3uy; 0x3duy; 0x2buy; 0xefuy; 0xcduy; 0x28uy; 0x5buy; 0x83uy; 0xccuy; 0x18uy; 0x91uy; 0x88uy; 0xb0uy; 0x2euy; 0xf9uy; 0x29uy; 0x31uy; 0x18uy; 0xf9uy; 0x4euy; 0xe9uy; 0x0auy; 0x91uy; 0x92uy; 0x9fuy; 0xaeuy; 0x2duy; 0xaduy; 0xf4uy; 0xe6uy; 0x1auy; 0xe2uy; 0xa4uy; 0xeeuy; 0x47uy; 0x15uy; 0xbfuy; 0x83uy; 0x6euy; 0xd7uy; 0x72uy; 0x12uy; 0x3buy; 0x2duy; 0x24uy; 0xe9uy; 0xb2uy; 0x55uy; 0xcbuy; 0x3cuy; 0x10uy; 0xf0uy; 0x24uy; 0x8auy; 0x4auy; 0x02uy; 0xeauy; 0x90uy; 0x25uy; 0xf0uy; 0xb4uy; 0x79uy; 0x3auy; 0xefuy; 0x6euy; 0xf5uy; 0x52uy; 0xdfuy; 0xb0uy; 0x0auy; 0xcduy; 0x24uy; 0x1cuy; 0xd3uy; 0x2euy; 0x22uy; 0x74uy; 0xeauy; 0x21uy; 0x6fuy; 0xe9uy; 0xbduy; 0xc8uy; 0x3euy; 0x36uy; 0x5buy; 0x19uy; 0xf1uy; 0xcauy; 0x99uy; 0x0auy; 0xb4uy; 0xa7uy; 0x52uy; 0x1auy; 0x4euy; 0xf2uy; 0xaduy; 0x8duy; 0x56uy; 0x85uy; 0xbbuy; 0x64uy; 0x89uy; 0xbauy; 0x26uy; 0xf9uy; 0xc7uy; 0xe1uy; 0x89uy; 0x19uy; 0x22uy; 0x77uy; 0xc3uy; 0xa8uy; 0xfcuy; 0xffuy; 0xaduy; 0xfeuy; 0xb9uy; 0x48uy; 0xaeuy; 0x12uy; 0x30uy; 0x9fuy; 0x19uy; 0xfbuy; 0x1buy; 0xefuy; 0x14uy; 0x87uy; 0x8auy; 0x78uy; 0x71uy; 0xf3uy; 0xf4uy; 0xb7uy; 0x00uy; 0x9cuy; 0x1duy; 0xb5uy; 0x3duy; 0x49uy; 0x00uy; 0x0cuy; 0x06uy; 0xd4uy; 0x50uy; 0xf9uy; 0x54uy; 0x45uy; 0xb2uy; 0x5buy; 0x43uy; 0xdbuy; 0x6duy; 0xcfuy; 0x1auy; 0xe9uy; 0x7auy; 0x7auy; 0xcfuy; 0xfcuy; 0x8auy; 0x4euy; 0x4duy; 0x0buy; 0x07uy; 0x63uy; 0x28uy; 0xd8uy; 0xe7uy; 0x08uy; 0x95uy; 0xdfuy; 0xa6uy; 0x72uy; 0x93uy; 0x2euy; 0xbbuy; 0xa0uy; 0x42uy; 0x89uy; 0x16uy; 0xf1uy; 0xd9uy; 0x0cuy; 0xf9uy; 0xa1uy; 0x16uy; 0xfduy; 0xd9uy; 0x03uy; 0xb4uy; 0x3buy; 0x8auy; 0xf5uy; 0xf6uy; 0xe7uy; 0x6buy; 0x2euy; 0x8euy; 0x4cuy; 0x3duy; 0xe2uy; 0xafuy; 0x08uy; 0x45uy; 0x03uy; 0xffuy; 0x09uy; 0xb6uy; 0xebuy; 0x2duy; 0xc6uy; 0x1buy; 0x88uy; 0x94uy; 0xacuy; 0x3euy; 0xf1uy; 0x9fuy; 0x0euy; 0x0euy; 0x2buy; 0xd5uy; 0x00uy; 0x4duy; 0x3fuy; 0x3buy; 0x53uy; 0xaeuy; 0xafuy; 0x1cuy; 0x33uy; 0x5fuy; 0x55uy; 0x6euy; 0x8duy; 0xafuy; 0x05uy; 0x7auy; 0x10uy; 0x34uy; 0xc9uy; 0xf4uy; 0x66uy; 0xcbuy; 0x62uy; 0x12uy; 0xa6uy; 0xeeuy; 0xe8uy; 0x1cuy; 0x5duy; 0x12uy; 0x86uy; 0xdbuy; 0x6fuy; 0x1cuy; 0x33uy; 0xc4uy; 0x1cuy; 0xdauy; 0x82uy; 0x2duy; 0x3buy; 0x59uy; 0xfeuy; 0xb1uy; 0xa4uy; 0x59uy; 0x41uy; 0x86uy; 0xd0uy; 0xefuy; 0xaeuy; 0xfbuy; 0xdauy; 0x6duy; 0x11uy; 0xb8uy; 0xcauy; 0xe9uy; 0x6euy; 0xffuy; 0xf7uy; 0xa9uy; 0xd9uy; 0x70uy; 0x30uy; 0xfcuy; 0x53uy; 0xe2uy; 0xd7uy; 0xa2uy; 0x4euy; 0xc7uy; 0x91uy; 0xd9uy; 0x07uy; 0x06uy; 0xaauy; 0xdduy; 0xb0uy; 0x59uy; 0x28uy; 0x1duy; 0x00uy; 0x66uy; 0xc5uy; 0x54uy; 0xc2uy; 0xfcuy; 0x06uy; 0xdauy; 0x05uy; 0x90uy; 0x52uy; 0x1duy; 0x37uy; 0x66uy; 0xeeuy; 0xf0uy; 0xb2uy; 0x55uy; 0x8auy; 0x5duy; 0xd2uy; 0x38uy; 0x86uy; 0x94uy; 0x9buy; 0xfcuy; 0x10uy; 0x4cuy; 0xa1uy; 0xb9uy; 0x64uy; 0x3euy; 0x44uy; 0xb8uy; 0x5fuy; 0xb0uy; 0x0cuy; 0xecuy; 0xe0uy; 0xc9uy; 0xe5uy; 0x62uy; 0x75uy; 0x3fuy; 0x09uy; 0xd5uy; 0xf5uy; 0xd9uy; 0x26uy; 0xbauy; 0x9euy; 0xd2uy; 0xf4uy; 0xb9uy; 0x48uy; 0x0auy; 0xbcuy; 0xa2uy; 0xd6uy; 0x7cuy; 0x36uy; 0x11uy; 0x7duy; 0x26uy; 0x81uy; 0x89uy; 0xcfuy; 0xa4uy; 0xaduy; 0x73uy; 0x0euy; 0xeeuy; 0xccuy; 0x06uy; 0xa9uy; 0xdbuy; 0xb1uy; 0xfduy; 0xfbuy; 0x09uy; 0x7fuy; 0x90uy; 0x42uy; 0x37uy; 0x2fuy; 0xe1uy; 0x9cuy; 0x0fuy; 0x6fuy; 0xcfuy; 0x43uy; 0xb5uy; 0xd9uy; 0x90uy; 0xe1uy; 0x85uy; 0xf5uy; 0xa8uy; 0xaeuy; ] in
assert_norm (List.Tot.length l = 529);
B.gcmalloc_of_list HyperStack.root l | {
"file_name": "providers/test/vectors/Test.Vectors.Chacha20Poly1305.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 362,
"start_col": 0,
"start_line": 359
} | module Test.Vectors.Chacha20Poly1305
module B = LowStar.Buffer
#set-options "--max_fuel 0 --max_ifuel 0"
let key0: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x1cuy; 0x92uy; 0x40uy; 0xa5uy; 0xebuy; 0x55uy; 0xd3uy; 0x8auy; 0xf3uy; 0x33uy; 0x88uy; 0x86uy; 0x04uy; 0xf6uy; 0xb5uy; 0xf0uy; 0x47uy; 0x39uy; 0x17uy; 0xc1uy; 0x40uy; 0x2buy; 0x80uy; 0x09uy; 0x9duy; 0xcauy; 0x5cuy; 0xbcuy; 0x20uy; 0x70uy; 0x75uy; 0xc0uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key0_len: (x:UInt32.t { UInt32.v x = B.length key0 }) =
32ul
let nonce0: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x01uy; 0x02uy; 0x03uy; 0x04uy; 0x05uy; 0x06uy; 0x07uy; 0x08uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce0_len: (x:UInt32.t { UInt32.v x = B.length nonce0 }) =
12ul
let aad0: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf3uy; 0x33uy; 0x88uy; 0x86uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x4euy; 0x91uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad0_len: (x:UInt32.t { UInt32.v x = B.length aad0 }) =
12ul
let input0: (b: B.buffer UInt8.t { B.length b = 265 /\ B.recallable b /\ B.disjoint b aad0 }) =
B.recall aad0;[@inline_let] let l = [ 0x49uy; 0x6euy; 0x74uy; 0x65uy; 0x72uy; 0x6euy; 0x65uy; 0x74uy; 0x2duy; 0x44uy; 0x72uy; 0x61uy; 0x66uy; 0x74uy; 0x73uy; 0x20uy; 0x61uy; 0x72uy; 0x65uy; 0x20uy; 0x64uy; 0x72uy; 0x61uy; 0x66uy; 0x74uy; 0x20uy; 0x64uy; 0x6fuy; 0x63uy; 0x75uy; 0x6duy; 0x65uy; 0x6euy; 0x74uy; 0x73uy; 0x20uy; 0x76uy; 0x61uy; 0x6cuy; 0x69uy; 0x64uy; 0x20uy; 0x66uy; 0x6fuy; 0x72uy; 0x20uy; 0x61uy; 0x20uy; 0x6duy; 0x61uy; 0x78uy; 0x69uy; 0x6duy; 0x75uy; 0x6duy; 0x20uy; 0x6fuy; 0x66uy; 0x20uy; 0x73uy; 0x69uy; 0x78uy; 0x20uy; 0x6duy; 0x6fuy; 0x6euy; 0x74uy; 0x68uy; 0x73uy; 0x20uy; 0x61uy; 0x6euy; 0x64uy; 0x20uy; 0x6duy; 0x61uy; 0x79uy; 0x20uy; 0x62uy; 0x65uy; 0x20uy; 0x75uy; 0x70uy; 0x64uy; 0x61uy; 0x74uy; 0x65uy; 0x64uy; 0x2cuy; 0x20uy; 0x72uy; 0x65uy; 0x70uy; 0x6cuy; 0x61uy; 0x63uy; 0x65uy; 0x64uy; 0x2cuy; 0x20uy; 0x6fuy; 0x72uy; 0x20uy; 0x6fuy; 0x62uy; 0x73uy; 0x6fuy; 0x6cuy; 0x65uy; 0x74uy; 0x65uy; 0x64uy; 0x20uy; 0x62uy; 0x79uy; 0x20uy; 0x6fuy; 0x74uy; 0x68uy; 0x65uy; 0x72uy; 0x20uy; 0x64uy; 0x6fuy; 0x63uy; 0x75uy; 0x6duy; 0x65uy; 0x6euy; 0x74uy; 0x73uy; 0x20uy; 0x61uy; 0x74uy; 0x20uy; 0x61uy; 0x6euy; 0x79uy; 0x20uy; 0x74uy; 0x69uy; 0x6duy; 0x65uy; 0x2euy; 0x20uy; 0x49uy; 0x74uy; 0x20uy; 0x69uy; 0x73uy; 0x20uy; 0x69uy; 0x6euy; 0x61uy; 0x70uy; 0x70uy; 0x72uy; 0x6fuy; 0x70uy; 0x72uy; 0x69uy; 0x61uy; 0x74uy; 0x65uy; 0x20uy; 0x74uy; 0x6fuy; 0x20uy; 0x75uy; 0x73uy; 0x65uy; 0x20uy; 0x49uy; 0x6euy; 0x74uy; 0x65uy; 0x72uy; 0x6euy; 0x65uy; 0x74uy; 0x2duy; 0x44uy; 0x72uy; 0x61uy; 0x66uy; 0x74uy; 0x73uy; 0x20uy; 0x61uy; 0x73uy; 0x20uy; 0x72uy; 0x65uy; 0x66uy; 0x65uy; 0x72uy; 0x65uy; 0x6euy; 0x63uy; 0x65uy; 0x20uy; 0x6duy; 0x61uy; 0x74uy; 0x65uy; 0x72uy; 0x69uy; 0x61uy; 0x6cuy; 0x20uy; 0x6fuy; 0x72uy; 0x20uy; 0x74uy; 0x6fuy; 0x20uy; 0x63uy; 0x69uy; 0x74uy; 0x65uy; 0x20uy; 0x74uy; 0x68uy; 0x65uy; 0x6duy; 0x20uy; 0x6fuy; 0x74uy; 0x68uy; 0x65uy; 0x72uy; 0x20uy; 0x74uy; 0x68uy; 0x61uy; 0x6euy; 0x20uy; 0x61uy; 0x73uy; 0x20uy; 0x2fuy; 0xe2uy; 0x80uy; 0x9cuy; 0x77uy; 0x6fuy; 0x72uy; 0x6buy; 0x20uy; 0x69uy; 0x6euy; 0x20uy; 0x70uy; 0x72uy; 0x6fuy; 0x67uy; 0x72uy; 0x65uy; 0x73uy; 0x73uy; 0x2euy; 0x2fuy; 0xe2uy; 0x80uy; 0x9duy; ] in
assert_norm (List.Tot.length l = 265);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input0_len: (x:UInt32.t { UInt32.v x = B.length input0 }) =
265ul
let output0: (b: B.buffer UInt8.t { B.length b = 281 /\ B.recallable b }) =
[@inline_let] let l = [ 0x64uy; 0xa0uy; 0x86uy; 0x15uy; 0x75uy; 0x86uy; 0x1auy; 0xf4uy; 0x60uy; 0xf0uy; 0x62uy; 0xc7uy; 0x9buy; 0xe6uy; 0x43uy; 0xbduy; 0x5euy; 0x80uy; 0x5cuy; 0xfduy; 0x34uy; 0x5cuy; 0xf3uy; 0x89uy; 0xf1uy; 0x08uy; 0x67uy; 0x0auy; 0xc7uy; 0x6cuy; 0x8cuy; 0xb2uy; 0x4cuy; 0x6cuy; 0xfcuy; 0x18uy; 0x75uy; 0x5duy; 0x43uy; 0xeeuy; 0xa0uy; 0x9euy; 0xe9uy; 0x4euy; 0x38uy; 0x2duy; 0x26uy; 0xb0uy; 0xbduy; 0xb7uy; 0xb7uy; 0x3cuy; 0x32uy; 0x1buy; 0x01uy; 0x00uy; 0xd4uy; 0xf0uy; 0x3buy; 0x7fuy; 0x35uy; 0x58uy; 0x94uy; 0xcfuy; 0x33uy; 0x2fuy; 0x83uy; 0x0euy; 0x71uy; 0x0buy; 0x97uy; 0xceuy; 0x98uy; 0xc8uy; 0xa8uy; 0x4auy; 0xbduy; 0x0buy; 0x94uy; 0x81uy; 0x14uy; 0xaduy; 0x17uy; 0x6euy; 0x00uy; 0x8duy; 0x33uy; 0xbduy; 0x60uy; 0xf9uy; 0x82uy; 0xb1uy; 0xffuy; 0x37uy; 0xc8uy; 0x55uy; 0x97uy; 0x97uy; 0xa0uy; 0x6euy; 0xf4uy; 0xf0uy; 0xefuy; 0x61uy; 0xc1uy; 0x86uy; 0x32uy; 0x4euy; 0x2buy; 0x35uy; 0x06uy; 0x38uy; 0x36uy; 0x06uy; 0x90uy; 0x7buy; 0x6auy; 0x7cuy; 0x02uy; 0xb0uy; 0xf9uy; 0xf6uy; 0x15uy; 0x7buy; 0x53uy; 0xc8uy; 0x67uy; 0xe4uy; 0xb9uy; 0x16uy; 0x6cuy; 0x76uy; 0x7buy; 0x80uy; 0x4duy; 0x46uy; 0xa5uy; 0x9buy; 0x52uy; 0x16uy; 0xcduy; 0xe7uy; 0xa4uy; 0xe9uy; 0x90uy; 0x40uy; 0xc5uy; 0xa4uy; 0x04uy; 0x33uy; 0x22uy; 0x5euy; 0xe2uy; 0x82uy; 0xa1uy; 0xb0uy; 0xa0uy; 0x6cuy; 0x52uy; 0x3euy; 0xafuy; 0x45uy; 0x34uy; 0xd7uy; 0xf8uy; 0x3fuy; 0xa1uy; 0x15uy; 0x5buy; 0x00uy; 0x47uy; 0x71uy; 0x8cuy; 0xbcuy; 0x54uy; 0x6auy; 0x0duy; 0x07uy; 0x2buy; 0x04uy; 0xb3uy; 0x56uy; 0x4euy; 0xeauy; 0x1buy; 0x42uy; 0x22uy; 0x73uy; 0xf5uy; 0x48uy; 0x27uy; 0x1auy; 0x0buy; 0xb2uy; 0x31uy; 0x60uy; 0x53uy; 0xfauy; 0x76uy; 0x99uy; 0x19uy; 0x55uy; 0xebuy; 0xd6uy; 0x31uy; 0x59uy; 0x43uy; 0x4euy; 0xceuy; 0xbbuy; 0x4euy; 0x46uy; 0x6duy; 0xaeuy; 0x5auy; 0x10uy; 0x73uy; 0xa6uy; 0x72uy; 0x76uy; 0x27uy; 0x09uy; 0x7auy; 0x10uy; 0x49uy; 0xe6uy; 0x17uy; 0xd9uy; 0x1duy; 0x36uy; 0x10uy; 0x94uy; 0xfauy; 0x68uy; 0xf0uy; 0xffuy; 0x77uy; 0x98uy; 0x71uy; 0x30uy; 0x30uy; 0x5buy; 0xeauy; 0xbauy; 0x2euy; 0xdauy; 0x04uy; 0xdfuy; 0x99uy; 0x7buy; 0x71uy; 0x4duy; 0x6cuy; 0x6fuy; 0x2cuy; 0x29uy; 0xa6uy; 0xaduy; 0x5cuy; 0xb4uy; 0x02uy; 0x2buy; 0x02uy; 0x70uy; 0x9buy; 0xeeuy; 0xaduy; 0x9duy; 0x67uy; 0x89uy; 0x0cuy; 0xbbuy; 0x22uy; 0x39uy; 0x23uy; 0x36uy; 0xfeuy; 0xa1uy; 0x85uy; 0x1fuy; 0x38uy; ] in
assert_norm (List.Tot.length l = 281);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let output0_len: (x:UInt32.t { UInt32.v x = B.length output0 }) =
281ul
let key1: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x4cuy; 0xf5uy; 0x96uy; 0x83uy; 0x38uy; 0xe6uy; 0xaeuy; 0x7fuy; 0x2duy; 0x29uy; 0x25uy; 0x76uy; 0xd5uy; 0x75uy; 0x27uy; 0x86uy; 0x91uy; 0x9auy; 0x27uy; 0x7auy; 0xfbuy; 0x46uy; 0xc5uy; 0xefuy; 0x94uy; 0x81uy; 0x79uy; 0x57uy; 0x14uy; 0x59uy; 0x40uy; 0x68uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key1_len: (x:UInt32.t { UInt32.v x = B.length key1 }) =
32ul
let nonce1: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xcauy; 0xbfuy; 0x33uy; 0x71uy; 0x32uy; 0x45uy; 0x77uy; 0x8euy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce1_len: (x:UInt32.t { UInt32.v x = B.length nonce1 }) =
12ul
let aad1: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad1_len: (x:UInt32.t { UInt32.v x = B.length aad1 }) =
0ul
let input1: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b /\ B.disjoint b aad1 }) =
B.recall aad1;[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input1_len: (x:UInt32.t { UInt32.v x = B.length input1 }) =
0ul
let output1: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xeauy; 0xe0uy; 0x1euy; 0x9euy; 0x2cuy; 0x91uy; 0xaauy; 0xe1uy; 0xdbuy; 0x5duy; 0x99uy; 0x3fuy; 0x8auy; 0xf7uy; 0x69uy; 0x92uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let output1_len: (x:UInt32.t { UInt32.v x = B.length output1 }) =
16ul
let key2: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x2duy; 0xb0uy; 0x5duy; 0x40uy; 0xc8uy; 0xeduy; 0x44uy; 0x88uy; 0x34uy; 0xd1uy; 0x13uy; 0xafuy; 0x57uy; 0xa1uy; 0xebuy; 0x3auy; 0x2auy; 0x80uy; 0x51uy; 0x36uy; 0xecuy; 0x5buy; 0xbcuy; 0x08uy; 0x93uy; 0x84uy; 0x21uy; 0xb5uy; 0x13uy; 0x88uy; 0x3cuy; 0x0duy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key2_len: (x:UInt32.t { UInt32.v x = B.length key2 }) =
32ul
let nonce2: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x3duy; 0x86uy; 0xb5uy; 0x6buy; 0xc8uy; 0xa3uy; 0x1fuy; 0x1duy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce2_len: (x:UInt32.t { UInt32.v x = B.length nonce2 }) =
12ul
let aad2: (b: B.buffer UInt8.t { B.length b = 8 /\ B.recallable b }) =
[@inline_let] let l = [ 0x33uy; 0x10uy; 0x41uy; 0x12uy; 0x1fuy; 0xf3uy; 0xd2uy; 0x6buy; ] in
assert_norm (List.Tot.length l = 8);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad2_len: (x:UInt32.t { UInt32.v x = B.length aad2 }) =
8ul
let input2: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b /\ B.disjoint b aad2 }) =
B.recall aad2;[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input2_len: (x:UInt32.t { UInt32.v x = B.length input2 }) =
0ul
let output2: (b: B.buffer UInt8.t { B.length b = 16 /\ B.recallable b }) =
[@inline_let] let l = [ 0xdduy; 0x6buy; 0x3buy; 0x82uy; 0xceuy; 0x5auy; 0xbduy; 0xd6uy; 0xa9uy; 0x35uy; 0x83uy; 0xd8uy; 0x8cuy; 0x3duy; 0x85uy; 0x77uy; ] in
assert_norm (List.Tot.length l = 16);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let output2_len: (x:UInt32.t { UInt32.v x = B.length output2 }) =
16ul
let key3: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x4buy; 0x28uy; 0x4buy; 0xa3uy; 0x7buy; 0xbeuy; 0xe9uy; 0xf8uy; 0x31uy; 0x80uy; 0x82uy; 0xd7uy; 0xd8uy; 0xe8uy; 0xb5uy; 0xa1uy; 0xe2uy; 0x18uy; 0x18uy; 0x8auy; 0x9cuy; 0xfauy; 0xa3uy; 0x3duy; 0x25uy; 0x71uy; 0x3euy; 0x40uy; 0xbcuy; 0x54uy; 0x7auy; 0x3euy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key3_len: (x:UInt32.t { UInt32.v x = B.length key3 }) =
32ul
let nonce3: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xd2uy; 0x32uy; 0x1fuy; 0x29uy; 0x28uy; 0xc6uy; 0xc4uy; 0xc4uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce3_len: (x:UInt32.t { UInt32.v x = B.length nonce3 }) =
12ul
let aad3: (b: B.buffer UInt8.t { B.length b = 8 /\ B.recallable b }) =
[@inline_let] let l = [ 0x6auy; 0xe2uy; 0xaduy; 0x3fuy; 0x88uy; 0x39uy; 0x5auy; 0x40uy; ] in
assert_norm (List.Tot.length l = 8);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad3_len: (x:UInt32.t { UInt32.v x = B.length aad3 }) =
8ul
let input3: (b: B.buffer UInt8.t { B.length b = 1 /\ B.recallable b /\ B.disjoint b aad3 }) =
B.recall aad3;[@inline_let] let l = [ 0xa4uy; ] in
assert_norm (List.Tot.length l = 1);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input3_len: (x:UInt32.t { UInt32.v x = B.length input3 }) =
1ul
let output3: (b: B.buffer UInt8.t { B.length b = 17 /\ B.recallable b }) =
[@inline_let] let l = [ 0xb7uy; 0x1buy; 0xb0uy; 0x73uy; 0x59uy; 0xb0uy; 0x84uy; 0xb2uy; 0x6duy; 0x8euy; 0xabuy; 0x94uy; 0x31uy; 0xa1uy; 0xaeuy; 0xacuy; 0x89uy; ] in
assert_norm (List.Tot.length l = 17);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let output3_len: (x:UInt32.t { UInt32.v x = B.length output3 }) =
17ul
let key4: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x66uy; 0xcauy; 0x9cuy; 0x23uy; 0x2auy; 0x4buy; 0x4buy; 0x31uy; 0x0euy; 0x92uy; 0x89uy; 0x8buy; 0xf4uy; 0x93uy; 0xc7uy; 0x87uy; 0x98uy; 0xa3uy; 0xd8uy; 0x39uy; 0xf8uy; 0xf4uy; 0xa7uy; 0x01uy; 0xc0uy; 0x2euy; 0x0auy; 0xa6uy; 0x7euy; 0x5auy; 0x78uy; 0x87uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key4_len: (x:UInt32.t { UInt32.v x = B.length key4 }) =
32ul
let nonce4: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x20uy; 0x1cuy; 0xaauy; 0x5fuy; 0x9cuy; 0xbfuy; 0x92uy; 0x30uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce4_len: (x:UInt32.t { UInt32.v x = B.length nonce4 }) =
12ul
let aad4: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad4_len: (x:UInt32.t { UInt32.v x = B.length aad4 }) =
0ul
let input4: (b: B.buffer UInt8.t { B.length b = 1 /\ B.recallable b /\ B.disjoint b aad4 }) =
B.recall aad4;[@inline_let] let l = [ 0x2duy; ] in
assert_norm (List.Tot.length l = 1);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input4_len: (x:UInt32.t { UInt32.v x = B.length input4 }) =
1ul
let output4: (b: B.buffer UInt8.t { B.length b = 17 /\ B.recallable b }) =
[@inline_let] let l = [ 0xbfuy; 0xe1uy; 0x5buy; 0x0buy; 0xdbuy; 0x6buy; 0xf5uy; 0x5euy; 0x6cuy; 0x5duy; 0x84uy; 0x44uy; 0x39uy; 0x81uy; 0xc1uy; 0x9cuy; 0xacuy; ] in
assert_norm (List.Tot.length l = 17);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let output4_len: (x:UInt32.t { UInt32.v x = B.length output4 }) =
17ul
let key5: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x68uy; 0x7buy; 0x8duy; 0x8euy; 0xe3uy; 0xc4uy; 0xdduy; 0xaeuy; 0xdfuy; 0x72uy; 0x7fuy; 0x53uy; 0x72uy; 0x25uy; 0x1euy; 0x78uy; 0x91uy; 0xcbuy; 0x69uy; 0x76uy; 0x1fuy; 0x49uy; 0x93uy; 0xf9uy; 0x6fuy; 0x21uy; 0xccuy; 0x39uy; 0x9cuy; 0xaduy; 0xb1uy; 0x01uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key5_len: (x:UInt32.t { UInt32.v x = B.length key5 }) =
32ul
let nonce5: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xdfuy; 0x51uy; 0x84uy; 0x82uy; 0x42uy; 0x0cuy; 0x75uy; 0x9cuy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce5_len: (x:UInt32.t { UInt32.v x = B.length nonce5 }) =
12ul
let aad5: (b: B.buffer UInt8.t { B.length b = 7 /\ B.recallable b }) =
[@inline_let] let l = [ 0x70uy; 0xd3uy; 0x33uy; 0xf3uy; 0x8buy; 0x18uy; 0x0buy; ] in
assert_norm (List.Tot.length l = 7);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad5_len: (x:UInt32.t { UInt32.v x = B.length aad5 }) =
7ul
let input5: (b: B.buffer UInt8.t { B.length b = 129 /\ B.recallable b /\ B.disjoint b aad5 }) =
B.recall aad5;[@inline_let] let l = [ 0x33uy; 0x2fuy; 0x94uy; 0xc1uy; 0xa4uy; 0xefuy; 0xccuy; 0x2auy; 0x5buy; 0xa6uy; 0xe5uy; 0x8fuy; 0x1duy; 0x40uy; 0xf0uy; 0x92uy; 0x3cuy; 0xd9uy; 0x24uy; 0x11uy; 0xa9uy; 0x71uy; 0xf9uy; 0x37uy; 0x14uy; 0x99uy; 0xfauy; 0xbeuy; 0xe6uy; 0x80uy; 0xdeuy; 0x50uy; 0xc9uy; 0x96uy; 0xd4uy; 0xb0uy; 0xecuy; 0x9euy; 0x17uy; 0xecuy; 0xd2uy; 0x5euy; 0x72uy; 0x99uy; 0xfcuy; 0x0auy; 0xe1uy; 0xcbuy; 0x48uy; 0xd2uy; 0x85uy; 0xdduy; 0x2fuy; 0x90uy; 0xe0uy; 0x66uy; 0x3buy; 0xe6uy; 0x20uy; 0x74uy; 0xbeuy; 0x23uy; 0x8fuy; 0xcbuy; 0xb4uy; 0xe4uy; 0xdauy; 0x48uy; 0x40uy; 0xa6uy; 0xd1uy; 0x1buy; 0xc7uy; 0x42uy; 0xceuy; 0x2fuy; 0x0cuy; 0xa6uy; 0x85uy; 0x6euy; 0x87uy; 0x37uy; 0x03uy; 0xb1uy; 0x7cuy; 0x25uy; 0x96uy; 0xa3uy; 0x05uy; 0xd8uy; 0xb0uy; 0xf4uy; 0xeduy; 0xeauy; 0xc2uy; 0xf0uy; 0x31uy; 0x98uy; 0x6cuy; 0xd1uy; 0x14uy; 0x25uy; 0xc0uy; 0xcbuy; 0x01uy; 0x74uy; 0xd0uy; 0x82uy; 0xf4uy; 0x36uy; 0xf5uy; 0x41uy; 0xd5uy; 0xdcuy; 0xcauy; 0xc5uy; 0xbbuy; 0x98uy; 0xfeuy; 0xfcuy; 0x69uy; 0x21uy; 0x70uy; 0xd8uy; 0xa4uy; 0x4buy; 0xc8uy; 0xdeuy; 0x8fuy; ] in
assert_norm (List.Tot.length l = 129);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input5_len: (x:UInt32.t { UInt32.v x = B.length input5 }) =
129ul
let output5: (b: B.buffer UInt8.t { B.length b = 145 /\ B.recallable b }) =
[@inline_let] let l = [ 0x8buy; 0x06uy; 0xd3uy; 0x31uy; 0xb0uy; 0x93uy; 0x45uy; 0xb1uy; 0x75uy; 0x6euy; 0x26uy; 0xf9uy; 0x67uy; 0xbcuy; 0x90uy; 0x15uy; 0x81uy; 0x2cuy; 0xb5uy; 0xf0uy; 0xc6uy; 0x2buy; 0xc7uy; 0x8cuy; 0x56uy; 0xd1uy; 0xbfuy; 0x69uy; 0x6cuy; 0x07uy; 0xa0uy; 0xdauy; 0x65uy; 0x27uy; 0xc9uy; 0x90uy; 0x3duy; 0xefuy; 0x4buy; 0x11uy; 0x0fuy; 0x19uy; 0x07uy; 0xfduy; 0x29uy; 0x92uy; 0xd9uy; 0xc8uy; 0xf7uy; 0x99uy; 0x2euy; 0x4auy; 0xd0uy; 0xb8uy; 0x2cuy; 0xdcuy; 0x93uy; 0xf5uy; 0x9euy; 0x33uy; 0x78uy; 0xd1uy; 0x37uy; 0xc3uy; 0x66uy; 0xd7uy; 0x5euy; 0xbcuy; 0x44uy; 0xbfuy; 0x53uy; 0xa5uy; 0xbcuy; 0xc4uy; 0xcbuy; 0x7buy; 0x3auy; 0x8euy; 0x7fuy; 0x02uy; 0xbduy; 0xbbuy; 0xe7uy; 0xcauy; 0xa6uy; 0x6cuy; 0x6buy; 0x93uy; 0x21uy; 0x93uy; 0x10uy; 0x61uy; 0xe7uy; 0x69uy; 0xd0uy; 0x78uy; 0xf3uy; 0x07uy; 0x5auy; 0x1auy; 0x8fuy; 0x73uy; 0xaauy; 0xb1uy; 0x4euy; 0xd3uy; 0xdauy; 0x4fuy; 0xf3uy; 0x32uy; 0xe1uy; 0x66uy; 0x3euy; 0x6cuy; 0xc6uy; 0x13uy; 0xbauy; 0x06uy; 0x5buy; 0xfcuy; 0x6auy; 0xe5uy; 0x6fuy; 0x60uy; 0xfbuy; 0x07uy; 0x40uy; 0xb0uy; 0x8cuy; 0x9duy; 0x84uy; 0x43uy; 0x6buy; 0xc1uy; 0xf7uy; 0x8duy; 0x8duy; 0x31uy; 0xf7uy; 0x7auy; 0x39uy; 0x4duy; 0x8fuy; 0x9auy; 0xebuy; ] in
assert_norm (List.Tot.length l = 145);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let output5_len: (x:UInt32.t { UInt32.v x = B.length output5 }) =
145ul
let key6: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0x8duy; 0xb8uy; 0x91uy; 0x48uy; 0xf0uy; 0xe7uy; 0x0auy; 0xbduy; 0xf9uy; 0x3fuy; 0xcduy; 0xd9uy; 0xa0uy; 0x1euy; 0x42uy; 0x4cuy; 0xe7uy; 0xdeuy; 0x25uy; 0x3duy; 0xa3uy; 0xd7uy; 0x05uy; 0x80uy; 0x8duy; 0xf2uy; 0x82uy; 0xacuy; 0x44uy; 0x16uy; 0x51uy; 0x01uy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key6_len: (x:UInt32.t { UInt32.v x = B.length key6 }) =
32ul
let nonce6: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xdeuy; 0x7buy; 0xefuy; 0xc3uy; 0x65uy; 0x1buy; 0x68uy; 0xb0uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce6_len: (x:UInt32.t { UInt32.v x = B.length nonce6 }) =
12ul
let aad6: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad6_len: (x:UInt32.t { UInt32.v x = B.length aad6 }) =
0ul
let input6: (b: B.buffer UInt8.t { B.length b = 256 /\ B.recallable b /\ B.disjoint b aad6 }) =
B.recall aad6;[@inline_let] let l = [ 0x9buy; 0x18uy; 0xdbuy; 0xdduy; 0x9auy; 0x0fuy; 0x3euy; 0xa5uy; 0x15uy; 0x17uy; 0xdeuy; 0xdfuy; 0x08uy; 0x9duy; 0x65uy; 0x0auy; 0x67uy; 0x30uy; 0x12uy; 0xe2uy; 0x34uy; 0x77uy; 0x4buy; 0xc1uy; 0xd9uy; 0xc6uy; 0x1fuy; 0xabuy; 0xc6uy; 0x18uy; 0x50uy; 0x17uy; 0xa7uy; 0x9duy; 0x3cuy; 0xa6uy; 0xc5uy; 0x35uy; 0x8cuy; 0x1cuy; 0xc0uy; 0xa1uy; 0x7cuy; 0x9fuy; 0x03uy; 0x89uy; 0xcauy; 0xe1uy; 0xe6uy; 0xe9uy; 0xd4uy; 0xd3uy; 0x88uy; 0xdbuy; 0xb4uy; 0x51uy; 0x9duy; 0xecuy; 0xb4uy; 0xfcuy; 0x52uy; 0xeeuy; 0x6duy; 0xf1uy; 0x75uy; 0x42uy; 0xc6uy; 0xfduy; 0xbduy; 0x7auy; 0x8euy; 0x86uy; 0xfcuy; 0x44uy; 0xb3uy; 0x4fuy; 0xf3uy; 0xeauy; 0x67uy; 0x5auy; 0x41uy; 0x13uy; 0xbauy; 0xb0uy; 0xdcuy; 0xe1uy; 0xd3uy; 0x2auy; 0x7cuy; 0x22uy; 0xb3uy; 0xcauy; 0xacuy; 0x6auy; 0x37uy; 0x98uy; 0x3euy; 0x1duy; 0x40uy; 0x97uy; 0xf7uy; 0x9buy; 0x1duy; 0x36uy; 0x6buy; 0xb3uy; 0x28uy; 0xbduy; 0x60uy; 0x82uy; 0x47uy; 0x34uy; 0xaauy; 0x2fuy; 0x7duy; 0xe9uy; 0xa8uy; 0x70uy; 0x81uy; 0x57uy; 0xd4uy; 0xb9uy; 0x77uy; 0x0auy; 0x9duy; 0x29uy; 0xa7uy; 0x84uy; 0x52uy; 0x4fuy; 0xc2uy; 0x4auy; 0x40uy; 0x3buy; 0x3cuy; 0xd4uy; 0xc9uy; 0x2auy; 0xdbuy; 0x4auy; 0x53uy; 0xc4uy; 0xbeuy; 0x80uy; 0xe9uy; 0x51uy; 0x7fuy; 0x8fuy; 0xc7uy; 0xa2uy; 0xceuy; 0x82uy; 0x5cuy; 0x91uy; 0x1euy; 0x74uy; 0xd9uy; 0xd0uy; 0xbduy; 0xd5uy; 0xf3uy; 0xfduy; 0xdauy; 0x4duy; 0x25uy; 0xb4uy; 0xbbuy; 0x2duy; 0xacuy; 0x2fuy; 0x3duy; 0x71uy; 0x85uy; 0x7buy; 0xcfuy; 0x3cuy; 0x7buy; 0x3euy; 0x0euy; 0x22uy; 0x78uy; 0x0cuy; 0x29uy; 0xbfuy; 0xe4uy; 0xf4uy; 0x57uy; 0xb3uy; 0xcbuy; 0x49uy; 0xa0uy; 0xfcuy; 0x1euy; 0x05uy; 0x4euy; 0x16uy; 0xbcuy; 0xd5uy; 0xa8uy; 0xa3uy; 0xeeuy; 0x05uy; 0x35uy; 0xc6uy; 0x7cuy; 0xabuy; 0x60uy; 0x14uy; 0x55uy; 0x1auy; 0x8euy; 0xc5uy; 0x88uy; 0x5duy; 0xd5uy; 0x81uy; 0xc2uy; 0x81uy; 0xa5uy; 0xc4uy; 0x60uy; 0xdbuy; 0xafuy; 0x77uy; 0x91uy; 0xe1uy; 0xceuy; 0xa2uy; 0x7euy; 0x7fuy; 0x42uy; 0xe3uy; 0xb0uy; 0x13uy; 0x1cuy; 0x1fuy; 0x25uy; 0x60uy; 0x21uy; 0xe2uy; 0x40uy; 0x5fuy; 0x99uy; 0xb7uy; 0x73uy; 0xecuy; 0x9buy; 0x2buy; 0xf0uy; 0x65uy; 0x11uy; 0xc8uy; 0xd0uy; 0x0auy; 0x9fuy; 0xd3uy; ] in
assert_norm (List.Tot.length l = 256);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input6_len: (x:UInt32.t { UInt32.v x = B.length input6 }) =
256ul
let output6: (b: B.buffer UInt8.t { B.length b = 272 /\ B.recallable b }) =
[@inline_let] let l = [ 0x85uy; 0x04uy; 0xc2uy; 0xeduy; 0x8duy; 0xfduy; 0x97uy; 0x5cuy; 0xd2uy; 0xb7uy; 0xe2uy; 0xc1uy; 0x6buy; 0xa3uy; 0xbauy; 0xf8uy; 0xc9uy; 0x50uy; 0xc3uy; 0xc6uy; 0xa5uy; 0xe3uy; 0xa4uy; 0x7cuy; 0xc3uy; 0x23uy; 0x49uy; 0x5euy; 0xa9uy; 0xb9uy; 0x32uy; 0xebuy; 0x8auy; 0x7cuy; 0xcauy; 0xe5uy; 0xecuy; 0xfbuy; 0x7cuy; 0xc0uy; 0xcbuy; 0x7duy; 0xdcuy; 0x2cuy; 0x9duy; 0x92uy; 0x55uy; 0x21uy; 0x0auy; 0xc8uy; 0x43uy; 0x63uy; 0x59uy; 0x0auy; 0x31uy; 0x70uy; 0x82uy; 0x67uy; 0x41uy; 0x03uy; 0xf8uy; 0xdfuy; 0xf2uy; 0xacuy; 0xa7uy; 0x02uy; 0xd4uy; 0xd5uy; 0x8auy; 0x2duy; 0xc8uy; 0x99uy; 0x19uy; 0x66uy; 0xd0uy; 0xf6uy; 0x88uy; 0x2cuy; 0x77uy; 0xd9uy; 0xd4uy; 0x0duy; 0x6cuy; 0xbduy; 0x98uy; 0xdeuy; 0xe7uy; 0x7fuy; 0xaduy; 0x7euy; 0x8auy; 0xfbuy; 0xe9uy; 0x4buy; 0xe5uy; 0xf7uy; 0xe5uy; 0x50uy; 0xa0uy; 0x90uy; 0x3fuy; 0xd6uy; 0x22uy; 0x53uy; 0xe3uy; 0xfeuy; 0x1buy; 0xccuy; 0x79uy; 0x3buy; 0xecuy; 0x12uy; 0x47uy; 0x52uy; 0xa7uy; 0xd6uy; 0x04uy; 0xe3uy; 0x52uy; 0xe6uy; 0x93uy; 0x90uy; 0x91uy; 0x32uy; 0x73uy; 0x79uy; 0xb8uy; 0xd0uy; 0x31uy; 0xdeuy; 0x1fuy; 0x9fuy; 0x2fuy; 0x05uy; 0x38uy; 0x54uy; 0x2fuy; 0x35uy; 0x04uy; 0x39uy; 0xe0uy; 0xa7uy; 0xbauy; 0xc6uy; 0x52uy; 0xf6uy; 0x37uy; 0x65uy; 0x4cuy; 0x07uy; 0xa9uy; 0x7euy; 0xb3uy; 0x21uy; 0x6fuy; 0x74uy; 0x8cuy; 0xc9uy; 0xdeuy; 0xdbuy; 0x65uy; 0x1buy; 0x9buy; 0xaauy; 0x60uy; 0xb1uy; 0x03uy; 0x30uy; 0x6buy; 0xb2uy; 0x03uy; 0xc4uy; 0x1cuy; 0x04uy; 0xf8uy; 0x0fuy; 0x64uy; 0xafuy; 0x46uy; 0xe4uy; 0x65uy; 0x99uy; 0x49uy; 0xe2uy; 0xeauy; 0xceuy; 0x78uy; 0x00uy; 0xd8uy; 0x8buy; 0xd5uy; 0x2euy; 0xcfuy; 0xfcuy; 0x40uy; 0x49uy; 0xe8uy; 0x58uy; 0xdcuy; 0x34uy; 0x9cuy; 0x8cuy; 0x61uy; 0xbfuy; 0x0auy; 0x8euy; 0xecuy; 0x39uy; 0xa9uy; 0x30uy; 0x05uy; 0x5auy; 0xd2uy; 0x56uy; 0x01uy; 0xc7uy; 0xdauy; 0x8fuy; 0x4euy; 0xbbuy; 0x43uy; 0xa3uy; 0x3auy; 0xf9uy; 0x15uy; 0x2auy; 0xd0uy; 0xa0uy; 0x7auy; 0x87uy; 0x34uy; 0x82uy; 0xfeuy; 0x8auy; 0xd1uy; 0x2duy; 0x5euy; 0xc7uy; 0xbfuy; 0x04uy; 0x53uy; 0x5fuy; 0x3buy; 0x36uy; 0xd4uy; 0x25uy; 0x5cuy; 0x34uy; 0x7auy; 0x8duy; 0xd5uy; 0x05uy; 0xceuy; 0x72uy; 0xcauy; 0xefuy; 0x7auy; 0x4buy; 0xbcuy; 0xb0uy; 0x10uy; 0x5cuy; 0x96uy; 0x42uy; 0x3auy; 0x00uy; 0x98uy; 0xcduy; 0x15uy; 0xe8uy; 0xb7uy; 0x53uy; ] in
assert_norm (List.Tot.length l = 272);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let output6_len: (x:UInt32.t { UInt32.v x = B.length output6 }) =
272ul
let key7: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xf2uy; 0xaauy; 0x4fuy; 0x99uy; 0xfduy; 0x3euy; 0xa8uy; 0x53uy; 0xc1uy; 0x44uy; 0xe9uy; 0x81uy; 0x18uy; 0xdcuy; 0xf5uy; 0xf0uy; 0x3euy; 0x44uy; 0x15uy; 0x59uy; 0xe0uy; 0xc5uy; 0x44uy; 0x86uy; 0xc3uy; 0x91uy; 0xa8uy; 0x75uy; 0xc0uy; 0x12uy; 0x46uy; 0xbauy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key7_len: (x:UInt32.t { UInt32.v x = B.length key7 }) =
32ul
let nonce7: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0x0euy; 0x0duy; 0x57uy; 0xbbuy; 0x7buy; 0x40uy; 0x54uy; 0x02uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce7_len: (x:UInt32.t { UInt32.v x = B.length nonce7 }) =
12ul
let aad7: (b: B.buffer UInt8.t { B.length b = 0 /\ B.recallable b }) =
[@inline_let] let l = [ ] in
assert_norm (List.Tot.length l = 0);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad7_len: (x:UInt32.t { UInt32.v x = B.length aad7 }) =
0ul
let input7: (b: B.buffer UInt8.t { B.length b = 512 /\ B.recallable b /\ B.disjoint b aad7 }) =
B.recall aad7;[@inline_let] let l = [ 0xc3uy; 0x09uy; 0x94uy; 0x62uy; 0xe6uy; 0x46uy; 0x2euy; 0x10uy; 0xbeuy; 0x00uy; 0xe4uy; 0xfcuy; 0xf3uy; 0x40uy; 0xa3uy; 0xe2uy; 0x0fuy; 0xc2uy; 0x8buy; 0x28uy; 0xdcuy; 0xbauy; 0xb4uy; 0x3cuy; 0xe4uy; 0x21uy; 0x58uy; 0x61uy; 0xcduy; 0x8buy; 0xcduy; 0xfbuy; 0xacuy; 0x94uy; 0xa1uy; 0x45uy; 0xf5uy; 0x1cuy; 0xe1uy; 0x12uy; 0xe0uy; 0x3buy; 0x67uy; 0x21uy; 0x54uy; 0x5euy; 0x8cuy; 0xaauy; 0xcfuy; 0xdbuy; 0xb4uy; 0x51uy; 0xd4uy; 0x13uy; 0xdauy; 0xe6uy; 0x83uy; 0x89uy; 0xb6uy; 0x92uy; 0xe9uy; 0x21uy; 0x76uy; 0xa4uy; 0x93uy; 0x7duy; 0x0euy; 0xfduy; 0x96uy; 0x36uy; 0x03uy; 0x91uy; 0x43uy; 0x5cuy; 0x92uy; 0x49uy; 0x62uy; 0x61uy; 0x7buy; 0xebuy; 0x43uy; 0x89uy; 0xb8uy; 0x12uy; 0x20uy; 0x43uy; 0xd4uy; 0x47uy; 0x06uy; 0x84uy; 0xeeuy; 0x47uy; 0xe9uy; 0x8auy; 0x73uy; 0x15uy; 0x0fuy; 0x72uy; 0xcfuy; 0xeduy; 0xceuy; 0x96uy; 0xb2uy; 0x7fuy; 0x21uy; 0x45uy; 0x76uy; 0xebuy; 0x26uy; 0x28uy; 0x83uy; 0x6auy; 0xaduy; 0xaauy; 0xa6uy; 0x81uy; 0xd8uy; 0x55uy; 0xb1uy; 0xa3uy; 0x85uy; 0xb3uy; 0x0cuy; 0xdfuy; 0xf1uy; 0x69uy; 0x2duy; 0x97uy; 0x05uy; 0x2auy; 0xbcuy; 0x7cuy; 0x7buy; 0x25uy; 0xf8uy; 0x80uy; 0x9duy; 0x39uy; 0x25uy; 0xf3uy; 0x62uy; 0xf0uy; 0x66uy; 0x5euy; 0xf4uy; 0xa0uy; 0xcfuy; 0xd8uy; 0xfduy; 0x4fuy; 0xb1uy; 0x1fuy; 0x60uy; 0x3auy; 0x08uy; 0x47uy; 0xafuy; 0xe1uy; 0xf6uy; 0x10uy; 0x77uy; 0x09uy; 0xa7uy; 0x27uy; 0x8fuy; 0x9auy; 0x97uy; 0x5auy; 0x26uy; 0xfauy; 0xfeuy; 0x41uy; 0x32uy; 0x83uy; 0x10uy; 0xe0uy; 0x1duy; 0xbfuy; 0x64uy; 0x0duy; 0xf4uy; 0x1cuy; 0x32uy; 0x35uy; 0xe5uy; 0x1buy; 0x36uy; 0xefuy; 0xd4uy; 0x4auy; 0x93uy; 0x4duy; 0x00uy; 0x7cuy; 0xecuy; 0x02uy; 0x07uy; 0x8buy; 0x5duy; 0x7duy; 0x1buy; 0x0euy; 0xd1uy; 0xa6uy; 0xa5uy; 0x5duy; 0x7duy; 0x57uy; 0x88uy; 0xa8uy; 0xccuy; 0x81uy; 0xb4uy; 0x86uy; 0x4euy; 0xb4uy; 0x40uy; 0xe9uy; 0x1duy; 0xc3uy; 0xb1uy; 0x24uy; 0x3euy; 0x7fuy; 0xccuy; 0x8auy; 0x24uy; 0x9buy; 0xdfuy; 0x6duy; 0xf0uy; 0x39uy; 0x69uy; 0x3euy; 0x4cuy; 0xc0uy; 0x96uy; 0xe4uy; 0x13uy; 0xdauy; 0x90uy; 0xdauy; 0xf4uy; 0x95uy; 0x66uy; 0x8buy; 0x17uy; 0x17uy; 0xfeuy; 0x39uy; 0x43uy; 0x25uy; 0xaauy; 0xdauy; 0xa0uy; 0x43uy; 0x3cuy; 0xb1uy; 0x41uy; 0x02uy; 0xa3uy; 0xf0uy; 0xa7uy; 0x19uy; 0x59uy; 0xbcuy; 0x1duy; 0x7duy; 0x6cuy; 0x6duy; 0x91uy; 0x09uy; 0x5cuy; 0xb7uy; 0x5buy; 0x01uy; 0xd1uy; 0x6fuy; 0x17uy; 0x21uy; 0x97uy; 0xbfuy; 0x89uy; 0x71uy; 0xa5uy; 0xb0uy; 0x6euy; 0x07uy; 0x45uy; 0xfduy; 0x9duy; 0xeauy; 0x07uy; 0xf6uy; 0x7auy; 0x9fuy; 0x10uy; 0x18uy; 0x22uy; 0x30uy; 0x73uy; 0xacuy; 0xd4uy; 0x6buy; 0x72uy; 0x44uy; 0xeduy; 0xd9uy; 0x19uy; 0x9buy; 0x2duy; 0x4auy; 0x41uy; 0xdduy; 0xd1uy; 0x85uy; 0x5euy; 0x37uy; 0x19uy; 0xeduy; 0xd2uy; 0x15uy; 0x8fuy; 0x5euy; 0x91uy; 0xdbuy; 0x33uy; 0xf2uy; 0xe4uy; 0xdbuy; 0xffuy; 0x98uy; 0xfbuy; 0xa3uy; 0xb5uy; 0xcauy; 0x21uy; 0x69uy; 0x08uy; 0xe7uy; 0x8auy; 0xdfuy; 0x90uy; 0xffuy; 0x3euy; 0xe9uy; 0x20uy; 0x86uy; 0x3cuy; 0xe9uy; 0xfcuy; 0x0buy; 0xfeuy; 0x5cuy; 0x61uy; 0xaauy; 0x13uy; 0x92uy; 0x7fuy; 0x7buy; 0xecuy; 0xe0uy; 0x6duy; 0xa8uy; 0x23uy; 0x22uy; 0xf6uy; 0x6buy; 0x77uy; 0xc4uy; 0xfeuy; 0x40uy; 0x07uy; 0x3buy; 0xb6uy; 0xf6uy; 0x8euy; 0x5fuy; 0xd4uy; 0xb9uy; 0xb7uy; 0x0fuy; 0x21uy; 0x04uy; 0xefuy; 0x83uy; 0x63uy; 0x91uy; 0x69uy; 0x40uy; 0xa3uy; 0x48uy; 0x5cuy; 0xd2uy; 0x60uy; 0xf9uy; 0x4fuy; 0x6cuy; 0x47uy; 0x8buy; 0x3buy; 0xb1uy; 0x9fuy; 0x8euy; 0xeeuy; 0x16uy; 0x8auy; 0x13uy; 0xfcuy; 0x46uy; 0x17uy; 0xc3uy; 0xc3uy; 0x32uy; 0x56uy; 0xf8uy; 0x3cuy; 0x85uy; 0x3auy; 0xb6uy; 0x3euy; 0xaauy; 0x89uy; 0x4fuy; 0xb3uy; 0xdfuy; 0x38uy; 0xfduy; 0xf1uy; 0xe4uy; 0x3auy; 0xc0uy; 0xe6uy; 0x58uy; 0xb5uy; 0x8fuy; 0xc5uy; 0x29uy; 0xa2uy; 0x92uy; 0x4auy; 0xb6uy; 0xa0uy; 0x34uy; 0x7fuy; 0xabuy; 0xb5uy; 0x8auy; 0x90uy; 0xa1uy; 0xdbuy; 0x4duy; 0xcauy; 0xb6uy; 0x2cuy; 0x41uy; 0x3cuy; 0xf7uy; 0x2buy; 0x21uy; 0xc3uy; 0xfduy; 0xf4uy; 0x17uy; 0x5cuy; 0xb5uy; 0x33uy; 0x17uy; 0x68uy; 0x2buy; 0x08uy; 0x30uy; 0xf3uy; 0xf7uy; 0x30uy; 0x3cuy; 0x96uy; 0xe6uy; 0x6auy; 0x20uy; 0x97uy; 0xe7uy; 0x4duy; 0x10uy; 0x5fuy; 0x47uy; 0x5fuy; 0x49uy; 0x96uy; 0x09uy; 0xf0uy; 0x27uy; 0x91uy; 0xc8uy; 0xf8uy; 0x5auy; 0x2euy; 0x79uy; 0xb5uy; 0xe2uy; 0xb8uy; 0xe8uy; 0xb9uy; 0x7buy; 0xd5uy; 0x10uy; 0xcbuy; 0xffuy; 0x5duy; 0x14uy; 0x73uy; 0xf3uy; ] in
assert_norm (List.Tot.length l = 512);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input7_len: (x:UInt32.t { UInt32.v x = B.length input7 }) =
512ul
let output7: (b: B.buffer UInt8.t { B.length b = 528 /\ B.recallable b }) =
[@inline_let] let l = [ 0x14uy; 0xf6uy; 0x41uy; 0x37uy; 0xa6uy; 0xd4uy; 0x27uy; 0xcduy; 0xdbuy; 0x06uy; 0x3euy; 0x9auy; 0x4euy; 0xabuy; 0xd5uy; 0xb1uy; 0x1euy; 0x6buy; 0xd2uy; 0xbcuy; 0x11uy; 0xf4uy; 0x28uy; 0x93uy; 0x63uy; 0x54uy; 0xefuy; 0xbbuy; 0x5euy; 0x1duy; 0x3auy; 0x1duy; 0x37uy; 0x3cuy; 0x0auy; 0x6cuy; 0x1euy; 0xc2uy; 0xd1uy; 0x2cuy; 0xb5uy; 0xa3uy; 0xb5uy; 0x7buy; 0xb8uy; 0x8fuy; 0x25uy; 0xa6uy; 0x1buy; 0x61uy; 0x1cuy; 0xecuy; 0x28uy; 0x58uy; 0x26uy; 0xa4uy; 0xa8uy; 0x33uy; 0x28uy; 0x25uy; 0x5cuy; 0x45uy; 0x05uy; 0xe5uy; 0x6cuy; 0x99uy; 0xe5uy; 0x45uy; 0xc4uy; 0xa2uy; 0x03uy; 0x84uy; 0x03uy; 0x73uy; 0x1euy; 0x8cuy; 0x49uy; 0xacuy; 0x20uy; 0xdduy; 0x8duy; 0xb3uy; 0xc4uy; 0xf5uy; 0xe7uy; 0x4fuy; 0xf1uy; 0xeduy; 0xa1uy; 0x98uy; 0xdeuy; 0xa4uy; 0x96uy; 0xdduy; 0x2fuy; 0xabuy; 0xabuy; 0x97uy; 0xcfuy; 0x3euy; 0xd2uy; 0x9euy; 0xb8uy; 0x13uy; 0x07uy; 0x28uy; 0x29uy; 0x19uy; 0xafuy; 0xfduy; 0xf2uy; 0x49uy; 0x43uy; 0xeauy; 0x49uy; 0x26uy; 0x91uy; 0xc1uy; 0x07uy; 0xd6uy; 0xbbuy; 0x81uy; 0x75uy; 0x35uy; 0x0duy; 0x24uy; 0x7fuy; 0xc8uy; 0xdauy; 0xd4uy; 0xb7uy; 0xebuy; 0xe8uy; 0x5cuy; 0x09uy; 0xa2uy; 0x2fuy; 0xdcuy; 0x28uy; 0x7duy; 0x3auy; 0x03uy; 0xfauy; 0x94uy; 0xb5uy; 0x1duy; 0x17uy; 0x99uy; 0x36uy; 0xc3uy; 0x1cuy; 0x18uy; 0x34uy; 0xe3uy; 0x9fuy; 0xf5uy; 0x55uy; 0x7cuy; 0xb0uy; 0x60uy; 0x9duy; 0xffuy; 0xacuy; 0xd4uy; 0x61uy; 0xf2uy; 0xaduy; 0xf8uy; 0xceuy; 0xc7uy; 0xbeuy; 0x5cuy; 0xd2uy; 0x95uy; 0xa8uy; 0x4buy; 0x77uy; 0x13uy; 0x19uy; 0x59uy; 0x26uy; 0xc9uy; 0xb7uy; 0x8fuy; 0x6auy; 0xcbuy; 0x2duy; 0x37uy; 0x91uy; 0xeauy; 0x92uy; 0x9cuy; 0x94uy; 0x5buy; 0xdauy; 0x0buy; 0xceuy; 0xfeuy; 0x30uy; 0x20uy; 0xf8uy; 0x51uy; 0xaduy; 0xf2uy; 0xbeuy; 0xe7uy; 0xc7uy; 0xffuy; 0xb3uy; 0x33uy; 0x91uy; 0x6auy; 0xc9uy; 0x1auy; 0x41uy; 0xc9uy; 0x0fuy; 0xf3uy; 0x10uy; 0x0euy; 0xfduy; 0x53uy; 0xffuy; 0x6cuy; 0x16uy; 0x52uy; 0xd9uy; 0xf3uy; 0xf7uy; 0x98uy; 0x2euy; 0xc9uy; 0x07uy; 0x31uy; 0x2cuy; 0x0cuy; 0x72uy; 0xd7uy; 0xc5uy; 0xc6uy; 0x08uy; 0x2auy; 0x7buy; 0xdauy; 0xbduy; 0x7euy; 0x02uy; 0xeauy; 0x1auy; 0xbbuy; 0xf2uy; 0x04uy; 0x27uy; 0x61uy; 0x28uy; 0x8euy; 0xf5uy; 0x04uy; 0x03uy; 0x1fuy; 0x4cuy; 0x07uy; 0x55uy; 0x82uy; 0xecuy; 0x1euy; 0xd7uy; 0x8buy; 0x2fuy; 0x65uy; 0x56uy; 0xd1uy; 0xd9uy; 0x1euy; 0x3cuy; 0xe9uy; 0x1fuy; 0x5euy; 0x98uy; 0x70uy; 0x38uy; 0x4auy; 0x8cuy; 0x49uy; 0xc5uy; 0x43uy; 0xa0uy; 0xa1uy; 0x8buy; 0x74uy; 0x9duy; 0x4cuy; 0x62uy; 0x0duy; 0x10uy; 0x0cuy; 0xf4uy; 0x6cuy; 0x8fuy; 0xe0uy; 0xaauy; 0x9auy; 0x8duy; 0xb7uy; 0xe0uy; 0xbeuy; 0x4cuy; 0x87uy; 0xf1uy; 0x98uy; 0x2fuy; 0xccuy; 0xeduy; 0xc0uy; 0x52uy; 0x29uy; 0xdcuy; 0x83uy; 0xf8uy; 0xfcuy; 0x2cuy; 0x0euy; 0xa8uy; 0x51uy; 0x4duy; 0x80uy; 0x0duy; 0xa3uy; 0xfeuy; 0xd8uy; 0x37uy; 0xe7uy; 0x41uy; 0x24uy; 0xfcuy; 0xfbuy; 0x75uy; 0xe3uy; 0x71uy; 0x7buy; 0x57uy; 0x45uy; 0xf5uy; 0x97uy; 0x73uy; 0x65uy; 0x63uy; 0x14uy; 0x74uy; 0xb8uy; 0x82uy; 0x9fuy; 0xf8uy; 0x60uy; 0x2fuy; 0x8auy; 0xf2uy; 0x4euy; 0xf1uy; 0x39uy; 0xdauy; 0x33uy; 0x91uy; 0xf8uy; 0x36uy; 0xe0uy; 0x8duy; 0x3fuy; 0x1fuy; 0x3buy; 0x56uy; 0xdcuy; 0xa0uy; 0x8fuy; 0x3cuy; 0x9duy; 0x71uy; 0x52uy; 0xa7uy; 0xb8uy; 0xc0uy; 0xa5uy; 0xc6uy; 0xa2uy; 0x73uy; 0xdauy; 0xf4uy; 0x4buy; 0x74uy; 0x5buy; 0x00uy; 0x3duy; 0x99uy; 0xd7uy; 0x96uy; 0xbauy; 0xe6uy; 0xe1uy; 0xa6uy; 0x96uy; 0x38uy; 0xaduy; 0xb3uy; 0xc0uy; 0xd2uy; 0xbauy; 0x91uy; 0x6buy; 0xf9uy; 0x19uy; 0xdduy; 0x3buy; 0xbeuy; 0xbeuy; 0x9cuy; 0x20uy; 0x50uy; 0xbauy; 0xa1uy; 0xd0uy; 0xceuy; 0x11uy; 0xbduy; 0x95uy; 0xd8uy; 0xd1uy; 0xdduy; 0x33uy; 0x85uy; 0x74uy; 0xdcuy; 0xdbuy; 0x66uy; 0x76uy; 0x44uy; 0xdcuy; 0x03uy; 0x74uy; 0x48uy; 0x35uy; 0x98uy; 0xb1uy; 0x18uy; 0x47uy; 0x94uy; 0x7duy; 0xffuy; 0x62uy; 0xe4uy; 0x58uy; 0x78uy; 0xabuy; 0xeduy; 0x95uy; 0x36uy; 0xd9uy; 0x84uy; 0x91uy; 0x82uy; 0x64uy; 0x41uy; 0xbbuy; 0x58uy; 0xe6uy; 0x1cuy; 0x20uy; 0x6duy; 0x15uy; 0x6buy; 0x13uy; 0x96uy; 0xe8uy; 0x35uy; 0x7fuy; 0xdcuy; 0x40uy; 0x2cuy; 0xe9uy; 0xbcuy; 0x8auy; 0x4fuy; 0x92uy; 0xecuy; 0x06uy; 0x2duy; 0x50uy; 0xdfuy; 0x93uy; 0x5duy; 0x65uy; 0x5auy; 0xa8uy; 0xfcuy; 0x20uy; 0x50uy; 0x14uy; 0xa9uy; 0x8auy; 0x7euy; 0x1duy; 0x08uy; 0x1fuy; 0xe2uy; 0x99uy; 0xd0uy; 0xbeuy; 0xfbuy; 0x3auy; 0x21uy; 0x9duy; 0xaduy; 0x86uy; 0x54uy; 0xfduy; 0x0duy; 0x98uy; 0x1cuy; 0x5auy; 0x6fuy; 0x1fuy; 0x9auy; 0x40uy; 0xcduy; 0xa2uy; 0xffuy; 0x6auy; 0xf1uy; 0x54uy; ] in
assert_norm (List.Tot.length l = 528);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let output7_len: (x:UInt32.t { UInt32.v x = B.length output7 }) =
528ul
let key8: (b: B.buffer UInt8.t { B.length b = 32 /\ B.recallable b }) =
[@inline_let] let l = [ 0xeauy; 0xbcuy; 0x56uy; 0x99uy; 0xe3uy; 0x50uy; 0xffuy; 0xc5uy; 0xccuy; 0x1auy; 0xd7uy; 0xc1uy; 0x57uy; 0x72uy; 0xeauy; 0x86uy; 0x5buy; 0x89uy; 0x88uy; 0x61uy; 0x3duy; 0x2fuy; 0x9buy; 0xb2uy; 0xe7uy; 0x9cuy; 0xecuy; 0x74uy; 0x6euy; 0x3euy; 0xf4uy; 0x3buy; ] in
assert_norm (List.Tot.length l = 32);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let key8_len: (x:UInt32.t { UInt32.v x = B.length key8 }) =
32ul
let nonce8: (b: B.buffer UInt8.t { B.length b = 12 /\ B.recallable b }) =
[@inline_let] let l = [ 0x00uy; 0x00uy; 0x00uy; 0x00uy; 0xefuy; 0x2duy; 0x63uy; 0xeeuy; 0x6buy; 0x80uy; 0x8buy; 0x78uy; ] in
assert_norm (List.Tot.length l = 12);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let nonce8_len: (x:UInt32.t { UInt32.v x = B.length nonce8 }) =
12ul
let aad8: (b: B.buffer UInt8.t { B.length b = 9 /\ B.recallable b }) =
[@inline_let] let l = [ 0x5auy; 0x27uy; 0xffuy; 0xebuy; 0xdfuy; 0x84uy; 0xb2uy; 0x9euy; 0xefuy; ] in
assert_norm (List.Tot.length l = 9);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let aad8_len: (x:UInt32.t { UInt32.v x = B.length aad8 }) =
9ul
let input8: (b: B.buffer UInt8.t { B.length b = 513 /\ B.recallable b /\ B.disjoint b aad8 }) =
B.recall aad8;[@inline_let] let l = [ 0xe6uy; 0xc3uy; 0xdbuy; 0x63uy; 0x55uy; 0x15uy; 0xe3uy; 0x5buy; 0xb7uy; 0x4buy; 0x27uy; 0x8buy; 0x5auy; 0xdduy; 0xc2uy; 0xe8uy; 0x3auy; 0x6buy; 0xd7uy; 0x81uy; 0x96uy; 0x35uy; 0x97uy; 0xcauy; 0xd7uy; 0x68uy; 0xe8uy; 0xefuy; 0xceuy; 0xabuy; 0xdauy; 0x09uy; 0x6euy; 0xd6uy; 0x8euy; 0xcbuy; 0x55uy; 0xb5uy; 0xe1uy; 0xe5uy; 0x57uy; 0xfduy; 0xc4uy; 0xe3uy; 0xe0uy; 0x18uy; 0x4fuy; 0x85uy; 0xf5uy; 0x3fuy; 0x7euy; 0x4buy; 0x88uy; 0xc9uy; 0x52uy; 0x44uy; 0x0fuy; 0xeauy; 0xafuy; 0x1fuy; 0x71uy; 0x48uy; 0x9fuy; 0x97uy; 0x6duy; 0xb9uy; 0x6fuy; 0x00uy; 0xa6uy; 0xdeuy; 0x2buy; 0x77uy; 0x8buy; 0x15uy; 0xaduy; 0x10uy; 0xa0uy; 0x2buy; 0x7buy; 0x41uy; 0x90uy; 0x03uy; 0x2duy; 0x69uy; 0xaeuy; 0xccuy; 0x77uy; 0x7cuy; 0xa5uy; 0x9duy; 0x29uy; 0x22uy; 0xc2uy; 0xeauy; 0xb4uy; 0x00uy; 0x1auy; 0xd2uy; 0x7auy; 0x98uy; 0x8auy; 0xf9uy; 0xf7uy; 0x82uy; 0xb0uy; 0xabuy; 0xd8uy; 0xa6uy; 0x94uy; 0x8duy; 0x58uy; 0x2fuy; 0x01uy; 0x9euy; 0x00uy; 0x20uy; 0xfcuy; 0x49uy; 0xdcuy; 0x0euy; 0x03uy; 0xe8uy; 0x45uy; 0x10uy; 0xd6uy; 0xa8uy; 0xdauy; 0x55uy; 0x10uy; 0x9auy; 0xdfuy; 0x67uy; 0x22uy; 0x8buy; 0x43uy; 0xabuy; 0x00uy; 0xbbuy; 0x02uy; 0xc8uy; 0xdduy; 0x7buy; 0x97uy; 0x17uy; 0xd7uy; 0x1duy; 0x9euy; 0x02uy; 0x5euy; 0x48uy; 0xdeuy; 0x8euy; 0xcfuy; 0x99uy; 0x07uy; 0x95uy; 0x92uy; 0x3cuy; 0x5fuy; 0x9fuy; 0xc5uy; 0x8auy; 0xc0uy; 0x23uy; 0xaauy; 0xd5uy; 0x8cuy; 0x82uy; 0x6euy; 0x16uy; 0x92uy; 0xb1uy; 0x12uy; 0x17uy; 0x07uy; 0xc3uy; 0xfbuy; 0x36uy; 0xf5uy; 0x6cuy; 0x35uy; 0xd6uy; 0x06uy; 0x1fuy; 0x9fuy; 0xa7uy; 0x94uy; 0xa2uy; 0x38uy; 0x63uy; 0x9cuy; 0xb0uy; 0x71uy; 0xb3uy; 0xa5uy; 0xd2uy; 0xd8uy; 0xbauy; 0x9fuy; 0x08uy; 0x01uy; 0xb3uy; 0xffuy; 0x04uy; 0x97uy; 0x73uy; 0x45uy; 0x1buy; 0xd5uy; 0xa9uy; 0x9cuy; 0x80uy; 0xafuy; 0x04uy; 0x9auy; 0x85uy; 0xdbuy; 0x32uy; 0x5buy; 0x5duy; 0x1auy; 0xc1uy; 0x36uy; 0x28uy; 0x10uy; 0x79uy; 0xf1uy; 0x3cuy; 0xbfuy; 0x1auy; 0x41uy; 0x5cuy; 0x4euy; 0xdfuy; 0xb2uy; 0x7cuy; 0x79uy; 0x3buy; 0x7auy; 0x62uy; 0x3duy; 0x4buy; 0xc9uy; 0x9buy; 0x2auy; 0x2euy; 0x7cuy; 0xa2uy; 0xb1uy; 0x11uy; 0x98uy; 0xa7uy; 0x34uy; 0x1auy; 0x00uy; 0xf3uy; 0xd1uy; 0xbcuy; 0x18uy; 0x22uy; 0xbauy; 0x02uy; 0x56uy; 0x62uy; 0x31uy; 0x10uy; 0x11uy; 0x6duy; 0xe0uy; 0x54uy; 0x9duy; 0x40uy; 0x1fuy; 0x26uy; 0x80uy; 0x41uy; 0xcauy; 0x3fuy; 0x68uy; 0x0fuy; 0x32uy; 0x1duy; 0x0auy; 0x8euy; 0x79uy; 0xd8uy; 0xa4uy; 0x1buy; 0x29uy; 0x1cuy; 0x90uy; 0x8euy; 0xc5uy; 0xe3uy; 0xb4uy; 0x91uy; 0x37uy; 0x9auy; 0x97uy; 0x86uy; 0x99uy; 0xd5uy; 0x09uy; 0xc5uy; 0xbbuy; 0xa3uy; 0x3fuy; 0x21uy; 0x29uy; 0x82uy; 0x14uy; 0x5cuy; 0xabuy; 0x25uy; 0xfbuy; 0xf2uy; 0x4fuy; 0x58uy; 0x26uy; 0xd4uy; 0x83uy; 0xaauy; 0x66uy; 0x89uy; 0x67uy; 0x7euy; 0xc0uy; 0x49uy; 0xe1uy; 0x11uy; 0x10uy; 0x7fuy; 0x7auy; 0xdauy; 0x29uy; 0x04uy; 0xffuy; 0xf0uy; 0xcbuy; 0x09uy; 0x7cuy; 0x9duy; 0xfauy; 0x03uy; 0x6fuy; 0x81uy; 0x09uy; 0x31uy; 0x60uy; 0xfbuy; 0x08uy; 0xfauy; 0x74uy; 0xd3uy; 0x64uy; 0x44uy; 0x7cuy; 0x55uy; 0x85uy; 0xecuy; 0x9cuy; 0x6euy; 0x25uy; 0xb7uy; 0x6cuy; 0xc5uy; 0x37uy; 0xb6uy; 0x83uy; 0x87uy; 0x72uy; 0x95uy; 0x8buy; 0x9duy; 0xe1uy; 0x69uy; 0x5cuy; 0x31uy; 0x95uy; 0x42uy; 0xa6uy; 0x2cuy; 0xd1uy; 0x36uy; 0x47uy; 0x1fuy; 0xecuy; 0x54uy; 0xabuy; 0xa2uy; 0x1cuy; 0xd8uy; 0x00uy; 0xccuy; 0xbcuy; 0x0duy; 0x65uy; 0xe2uy; 0x67uy; 0xbfuy; 0xbcuy; 0xeauy; 0xeeuy; 0x9euy; 0xe4uy; 0x36uy; 0x95uy; 0xbeuy; 0x73uy; 0xd9uy; 0xa6uy; 0xd9uy; 0x0fuy; 0xa0uy; 0xccuy; 0x82uy; 0x76uy; 0x26uy; 0xaduy; 0x5buy; 0x58uy; 0x6cuy; 0x4euy; 0xabuy; 0x29uy; 0x64uy; 0xd3uy; 0xd9uy; 0xa9uy; 0x08uy; 0x8cuy; 0x1duy; 0xa1uy; 0x4fuy; 0x80uy; 0xd8uy; 0x3fuy; 0x94uy; 0xfbuy; 0xd3uy; 0x7buy; 0xfcuy; 0xd1uy; 0x2buy; 0xc3uy; 0x21uy; 0xebuy; 0xe5uy; 0x1cuy; 0x84uy; 0x23uy; 0x7fuy; 0x4buy; 0xfauy; 0xdbuy; 0x34uy; 0x18uy; 0xa2uy; 0xc2uy; 0xe5uy; 0x13uy; 0xfeuy; 0x6cuy; 0x49uy; 0x81uy; 0xd2uy; 0x73uy; 0xe7uy; 0xe2uy; 0xd7uy; 0xe4uy; 0x4fuy; 0x4buy; 0x08uy; 0x6euy; 0xb1uy; 0x12uy; 0x22uy; 0x10uy; 0x9duy; 0xacuy; 0x51uy; 0x1euy; 0x17uy; 0xd9uy; 0x8auy; 0x0buy; 0x42uy; 0x88uy; 0x16uy; 0x81uy; 0x37uy; 0x7cuy; 0x6auy; 0xf7uy; 0xefuy; 0x2duy; 0xe3uy; 0xd9uy; 0xf8uy; 0x5fuy; 0xe0uy; 0x53uy; 0x27uy; 0x74uy; 0xb9uy; 0xe2uy; 0xd6uy; 0x1cuy; 0x80uy; 0x2cuy; 0x52uy; 0x65uy; ] in
assert_norm (List.Tot.length l = 513);
B.gcmalloc_of_list HyperStack.root l
inline_for_extraction let input8_len: (x:UInt32.t { UInt32.v x = B.length input8 }) =
513ul | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Test.Vectors.Chacha20Poly1305.fst"
} | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_module": "Test.Vectors",
"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": 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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | b:
LowStar.Buffer.buffer FStar.UInt8.t
{LowStar.Monotonic.Buffer.length b = 529 /\ LowStar.Monotonic.Buffer.recallable b} | Prims.Tot | [
"total"
] | [] | [
"LowStar.Buffer.gcmalloc_of_list",
"FStar.UInt8.t",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.Pervasives.normalize_term",
"FStar.List.Tot.Base.length",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.recallable",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"LowStar.Buffer.buffer",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | false | false | false | false | false | let output8:(b: B.buffer UInt8.t {B.length b = 529 /\ B.recallable b}) =
| [@@ inline_let ]let l =
[
0xfduy; 0x81uy; 0x8duy; 0xd0uy; 0x3duy; 0xb4uy; 0xd5uy; 0xdfuy; 0xd3uy; 0x42uy; 0x47uy; 0x5auy;
0x6duy; 0x19uy; 0x27uy; 0x66uy; 0x4buy; 0x2euy; 0x0cuy; 0x27uy; 0x9cuy; 0x96uy; 0x4cuy; 0x72uy;
0x02uy; 0xa3uy; 0x65uy; 0xc3uy; 0xb3uy; 0x6fuy; 0x2euy; 0xbduy; 0x63uy; 0x8auy; 0x4auy; 0x5duy;
0x29uy; 0xa2uy; 0xd0uy; 0x28uy; 0x48uy; 0xc5uy; 0x3duy; 0x98uy; 0xa3uy; 0xbcuy; 0xe0uy; 0xbeuy;
0x3buy; 0x3fuy; 0xe6uy; 0x8auy; 0xa4uy; 0x7fuy; 0x53uy; 0x06uy; 0xfauy; 0x7fuy; 0x27uy; 0x76uy;
0x72uy; 0x31uy; 0xa1uy; 0xf5uy; 0xd6uy; 0x0cuy; 0x52uy; 0x47uy; 0xbauy; 0xcduy; 0x4fuy; 0xd7uy;
0xebuy; 0x05uy; 0x48uy; 0x0duy; 0x7cuy; 0x35uy; 0x4auy; 0x09uy; 0xc9uy; 0x76uy; 0x71uy; 0x02uy;
0xa3uy; 0xfbuy; 0xb7uy; 0x1auy; 0x65uy; 0xb7uy; 0xeduy; 0x98uy; 0xc6uy; 0x30uy; 0x8auy; 0x00uy;
0xaeuy; 0xa1uy; 0x31uy; 0xe5uy; 0xb5uy; 0x9euy; 0x6duy; 0x62uy; 0xdauy; 0xdauy; 0x07uy; 0x0fuy;
0x38uy; 0x38uy; 0xd3uy; 0xcbuy; 0xc1uy; 0xb0uy; 0xaduy; 0xecuy; 0x72uy; 0xecuy; 0xb1uy; 0xa2uy;
0x7buy; 0x59uy; 0xf3uy; 0x3duy; 0x2buy; 0xefuy; 0xcduy; 0x28uy; 0x5buy; 0x83uy; 0xccuy; 0x18uy;
0x91uy; 0x88uy; 0xb0uy; 0x2euy; 0xf9uy; 0x29uy; 0x31uy; 0x18uy; 0xf9uy; 0x4euy; 0xe9uy; 0x0auy;
0x91uy; 0x92uy; 0x9fuy; 0xaeuy; 0x2duy; 0xaduy; 0xf4uy; 0xe6uy; 0x1auy; 0xe2uy; 0xa4uy; 0xeeuy;
0x47uy; 0x15uy; 0xbfuy; 0x83uy; 0x6euy; 0xd7uy; 0x72uy; 0x12uy; 0x3buy; 0x2duy; 0x24uy; 0xe9uy;
0xb2uy; 0x55uy; 0xcbuy; 0x3cuy; 0x10uy; 0xf0uy; 0x24uy; 0x8auy; 0x4auy; 0x02uy; 0xeauy; 0x90uy;
0x25uy; 0xf0uy; 0xb4uy; 0x79uy; 0x3auy; 0xefuy; 0x6euy; 0xf5uy; 0x52uy; 0xdfuy; 0xb0uy; 0x0auy;
0xcduy; 0x24uy; 0x1cuy; 0xd3uy; 0x2euy; 0x22uy; 0x74uy; 0xeauy; 0x21uy; 0x6fuy; 0xe9uy; 0xbduy;
0xc8uy; 0x3euy; 0x36uy; 0x5buy; 0x19uy; 0xf1uy; 0xcauy; 0x99uy; 0x0auy; 0xb4uy; 0xa7uy; 0x52uy;
0x1auy; 0x4euy; 0xf2uy; 0xaduy; 0x8duy; 0x56uy; 0x85uy; 0xbbuy; 0x64uy; 0x89uy; 0xbauy; 0x26uy;
0xf9uy; 0xc7uy; 0xe1uy; 0x89uy; 0x19uy; 0x22uy; 0x77uy; 0xc3uy; 0xa8uy; 0xfcuy; 0xffuy; 0xaduy;
0xfeuy; 0xb9uy; 0x48uy; 0xaeuy; 0x12uy; 0x30uy; 0x9fuy; 0x19uy; 0xfbuy; 0x1buy; 0xefuy; 0x14uy;
0x87uy; 0x8auy; 0x78uy; 0x71uy; 0xf3uy; 0xf4uy; 0xb7uy; 0x00uy; 0x9cuy; 0x1duy; 0xb5uy; 0x3duy;
0x49uy; 0x00uy; 0x0cuy; 0x06uy; 0xd4uy; 0x50uy; 0xf9uy; 0x54uy; 0x45uy; 0xb2uy; 0x5buy; 0x43uy;
0xdbuy; 0x6duy; 0xcfuy; 0x1auy; 0xe9uy; 0x7auy; 0x7auy; 0xcfuy; 0xfcuy; 0x8auy; 0x4euy; 0x4duy;
0x0buy; 0x07uy; 0x63uy; 0x28uy; 0xd8uy; 0xe7uy; 0x08uy; 0x95uy; 0xdfuy; 0xa6uy; 0x72uy; 0x93uy;
0x2euy; 0xbbuy; 0xa0uy; 0x42uy; 0x89uy; 0x16uy; 0xf1uy; 0xd9uy; 0x0cuy; 0xf9uy; 0xa1uy; 0x16uy;
0xfduy; 0xd9uy; 0x03uy; 0xb4uy; 0x3buy; 0x8auy; 0xf5uy; 0xf6uy; 0xe7uy; 0x6buy; 0x2euy; 0x8euy;
0x4cuy; 0x3duy; 0xe2uy; 0xafuy; 0x08uy; 0x45uy; 0x03uy; 0xffuy; 0x09uy; 0xb6uy; 0xebuy; 0x2duy;
0xc6uy; 0x1buy; 0x88uy; 0x94uy; 0xacuy; 0x3euy; 0xf1uy; 0x9fuy; 0x0euy; 0x0euy; 0x2buy; 0xd5uy;
0x00uy; 0x4duy; 0x3fuy; 0x3buy; 0x53uy; 0xaeuy; 0xafuy; 0x1cuy; 0x33uy; 0x5fuy; 0x55uy; 0x6euy;
0x8duy; 0xafuy; 0x05uy; 0x7auy; 0x10uy; 0x34uy; 0xc9uy; 0xf4uy; 0x66uy; 0xcbuy; 0x62uy; 0x12uy;
0xa6uy; 0xeeuy; 0xe8uy; 0x1cuy; 0x5duy; 0x12uy; 0x86uy; 0xdbuy; 0x6fuy; 0x1cuy; 0x33uy; 0xc4uy;
0x1cuy; 0xdauy; 0x82uy; 0x2duy; 0x3buy; 0x59uy; 0xfeuy; 0xb1uy; 0xa4uy; 0x59uy; 0x41uy; 0x86uy;
0xd0uy; 0xefuy; 0xaeuy; 0xfbuy; 0xdauy; 0x6duy; 0x11uy; 0xb8uy; 0xcauy; 0xe9uy; 0x6euy; 0xffuy;
0xf7uy; 0xa9uy; 0xd9uy; 0x70uy; 0x30uy; 0xfcuy; 0x53uy; 0xe2uy; 0xd7uy; 0xa2uy; 0x4euy; 0xc7uy;
0x91uy; 0xd9uy; 0x07uy; 0x06uy; 0xaauy; 0xdduy; 0xb0uy; 0x59uy; 0x28uy; 0x1duy; 0x00uy; 0x66uy;
0xc5uy; 0x54uy; 0xc2uy; 0xfcuy; 0x06uy; 0xdauy; 0x05uy; 0x90uy; 0x52uy; 0x1duy; 0x37uy; 0x66uy;
0xeeuy; 0xf0uy; 0xb2uy; 0x55uy; 0x8auy; 0x5duy; 0xd2uy; 0x38uy; 0x86uy; 0x94uy; 0x9buy; 0xfcuy;
0x10uy; 0x4cuy; 0xa1uy; 0xb9uy; 0x64uy; 0x3euy; 0x44uy; 0xb8uy; 0x5fuy; 0xb0uy; 0x0cuy; 0xecuy;
0xe0uy; 0xc9uy; 0xe5uy; 0x62uy; 0x75uy; 0x3fuy; 0x09uy; 0xd5uy; 0xf5uy; 0xd9uy; 0x26uy; 0xbauy;
0x9euy; 0xd2uy; 0xf4uy; 0xb9uy; 0x48uy; 0x0auy; 0xbcuy; 0xa2uy; 0xd6uy; 0x7cuy; 0x36uy; 0x11uy;
0x7duy; 0x26uy; 0x81uy; 0x89uy; 0xcfuy; 0xa4uy; 0xaduy; 0x73uy; 0x0euy; 0xeeuy; 0xccuy; 0x06uy;
0xa9uy; 0xdbuy; 0xb1uy; 0xfduy; 0xfbuy; 0x09uy; 0x7fuy; 0x90uy; 0x42uy; 0x37uy; 0x2fuy; 0xe1uy;
0x9cuy; 0x0fuy; 0x6fuy; 0xcfuy; 0x43uy; 0xb5uy; 0xd9uy; 0x90uy; 0xe1uy; 0x85uy; 0xf5uy; 0xa8uy;
0xaeuy
]
in
assert_norm (List.Tot.length l = 529);
B.gcmalloc_of_list HyperStack.root l | false |
Spec.Frodo.Sample.fst | Spec.Frodo.Sample.frodo_sample_matrix1 | val frodo_sample_matrix1:
a:frodo_alg
-> n1:size_nat
-> n2:size_nat{2 * n1 * n2 <= max_size_t}
-> r:lbytes (2 * n1 * n2)
-> i:size_nat{i < n1}
-> res:matrix n1 n2
-> matrix n1 n2 | val frodo_sample_matrix1:
a:frodo_alg
-> n1:size_nat
-> n2:size_nat{2 * n1 * n2 <= max_size_t}
-> r:lbytes (2 * n1 * n2)
-> i:size_nat{i < n1}
-> res:matrix n1 n2
-> matrix n1 n2 | let frodo_sample_matrix1 a n1 n2 r i res =
Loops.repeati n2 (frodo_sample_matrix0 a n1 n2 r i) res | {
"file_name": "specs/frodo/Spec.Frodo.Sample.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 57,
"end_line": 100,
"start_col": 0,
"start_line": 99
} | module Spec.Frodo.Sample
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
open Spec.Frodo.Lemmas
open Spec.Frodo.Params
module LSeq = Lib.Sequence
module Matrix = Spec.Matrix
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val frodo_sample_f:
a:frodo_alg
-> t:uint16
-> i:size_nat{i < cdf_table_len a}
-> res:nat{res = 0 \/ res = 1}
let frodo_sample_f a t i =
if v t > v (cdf_table a).[i] then 1 else 0
val frodo_sample_fc:
a:frodo_alg
-> t:uint16
-> i:size_nat{i <= cdf_table_len a}
-> GTot (res:nat{0 <= res /\ res <= i})
(decreases i)
let rec frodo_sample_fc a t i =
if i = 0 then 0
else frodo_sample_f a t (i - 1) + frodo_sample_fc a t (i - 1)
val frodo_sample_res:
a:frodo_alg
-> sign:uint16{v sign <= 1}
-> e:nat{e < cdf_table_len a}
-> uint16
let frodo_sample_res a r0 e =
let open FStar.Math.Lib in
let e = (powx (-1) (v r0)) * e in
assert_norm (powx (-1) 1 == -1);
assert_norm (powx (-1) 0 == 1);
assert (-cdf_table_len a < e /\ e < cdf_table_len a);
u16 (e % modulus U16)
#push-options "--fuel 1"
val frodo_sample: a:frodo_alg -> r:uint16 -> uint16
let frodo_sample a r =
let t = r >>. 1ul in
let r0 = r &. u16 1 in
mod_mask_lemma r 1ul;
assert (v #U16 #SEC (mod_mask 1ul) == 1);
assert (v r0 == 0 \/ v r0 == 1);
let e =
Loops.repeati_inductive
(cdf_table_len a - 1)
(fun z e -> 0 <= e /\ e <= z /\ e == frodo_sample_fc a t z)
(fun z e -> frodo_sample_f a t z + e) 0 in
frodo_sample_res a r0 e
#pop-options
// frodo_sample_matrix can be replaced with `creati`
val frodo_sample_matrix0:
a:frodo_alg
-> n1:size_nat
-> n2:size_nat{2 * n1 * n2 <= max_size_t}
-> r:lbytes (2 * n1 * n2)
-> i:size_nat{i < n1}
-> j:size_nat{j < n2}
-> res:matrix n1 n2
-> matrix n1 n2
let frodo_sample_matrix0 a n1 n2 r i j res =
lemma_matrix_index_repeati1 n1 n2 i j;
res.(i, j) <- frodo_sample a (uint_from_bytes_le (LSeq.sub r (2 * (i * n2 + j)) 2))
val frodo_sample_matrix1:
a:frodo_alg
-> n1:size_nat
-> n2:size_nat{2 * n1 * n2 <= max_size_t}
-> r:lbytes (2 * n1 * n2)
-> i:size_nat{i < n1}
-> res:matrix n1 n2
-> matrix n1 n2 | {
"checked_file": "/",
"dependencies": [
"Spec.Matrix.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.Lemmas.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Sample.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Spec.Matrix",
"short_module": "Matrix"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Frodo.Params.frodo_alg ->
n1: Lib.IntTypes.size_nat ->
n2: Lib.IntTypes.size_nat{(2 * n1) * n2 <= Lib.IntTypes.max_size_t} ->
r: Lib.ByteSequence.lbytes ((2 * n1) * n2) ->
i: Lib.IntTypes.size_nat{i < n1} ->
res: Spec.Matrix.matrix n1 n2
-> Spec.Matrix.matrix n1 n2 | Prims.Tot | [
"total"
] | [] | [
"Spec.Frodo.Params.frodo_alg",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Lib.ByteSequence.lbytes",
"Prims.op_LessThan",
"Spec.Matrix.matrix",
"Lib.LoopCombinators.repeati",
"Spec.Frodo.Sample.frodo_sample_matrix0"
] | [] | false | false | false | false | false | let frodo_sample_matrix1 a n1 n2 r i res =
| Loops.repeati n2 (frodo_sample_matrix0 a n1 n2 r i) res | false |
Spec.Frodo.Sample.fst | Spec.Frodo.Sample.frodo_sample_matrix | val frodo_sample_matrix:
a:frodo_alg
-> n1:size_nat
-> n2:size_nat{2 * n1 * n2 <= max_size_t}
-> r:lbytes (2 * n1 * n2)
-> matrix n1 n2 | val frodo_sample_matrix:
a:frodo_alg
-> n1:size_nat
-> n2:size_nat{2 * n1 * n2 <= max_size_t}
-> r:lbytes (2 * n1 * n2)
-> matrix n1 n2 | let frodo_sample_matrix a n1 n2 r =
let res = Matrix.create n1 n2 in
Loops.repeati n1 (frodo_sample_matrix1 a n1 n2 r) res | {
"file_name": "specs/frodo/Spec.Frodo.Sample.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 55,
"end_line": 112,
"start_col": 0,
"start_line": 110
} | module Spec.Frodo.Sample
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
open Spec.Frodo.Lemmas
open Spec.Frodo.Params
module LSeq = Lib.Sequence
module Matrix = Spec.Matrix
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val frodo_sample_f:
a:frodo_alg
-> t:uint16
-> i:size_nat{i < cdf_table_len a}
-> res:nat{res = 0 \/ res = 1}
let frodo_sample_f a t i =
if v t > v (cdf_table a).[i] then 1 else 0
val frodo_sample_fc:
a:frodo_alg
-> t:uint16
-> i:size_nat{i <= cdf_table_len a}
-> GTot (res:nat{0 <= res /\ res <= i})
(decreases i)
let rec frodo_sample_fc a t i =
if i = 0 then 0
else frodo_sample_f a t (i - 1) + frodo_sample_fc a t (i - 1)
val frodo_sample_res:
a:frodo_alg
-> sign:uint16{v sign <= 1}
-> e:nat{e < cdf_table_len a}
-> uint16
let frodo_sample_res a r0 e =
let open FStar.Math.Lib in
let e = (powx (-1) (v r0)) * e in
assert_norm (powx (-1) 1 == -1);
assert_norm (powx (-1) 0 == 1);
assert (-cdf_table_len a < e /\ e < cdf_table_len a);
u16 (e % modulus U16)
#push-options "--fuel 1"
val frodo_sample: a:frodo_alg -> r:uint16 -> uint16
let frodo_sample a r =
let t = r >>. 1ul in
let r0 = r &. u16 1 in
mod_mask_lemma r 1ul;
assert (v #U16 #SEC (mod_mask 1ul) == 1);
assert (v r0 == 0 \/ v r0 == 1);
let e =
Loops.repeati_inductive
(cdf_table_len a - 1)
(fun z e -> 0 <= e /\ e <= z /\ e == frodo_sample_fc a t z)
(fun z e -> frodo_sample_f a t z + e) 0 in
frodo_sample_res a r0 e
#pop-options
// frodo_sample_matrix can be replaced with `creati`
val frodo_sample_matrix0:
a:frodo_alg
-> n1:size_nat
-> n2:size_nat{2 * n1 * n2 <= max_size_t}
-> r:lbytes (2 * n1 * n2)
-> i:size_nat{i < n1}
-> j:size_nat{j < n2}
-> res:matrix n1 n2
-> matrix n1 n2
let frodo_sample_matrix0 a n1 n2 r i j res =
lemma_matrix_index_repeati1 n1 n2 i j;
res.(i, j) <- frodo_sample a (uint_from_bytes_le (LSeq.sub r (2 * (i * n2 + j)) 2))
val frodo_sample_matrix1:
a:frodo_alg
-> n1:size_nat
-> n2:size_nat{2 * n1 * n2 <= max_size_t}
-> r:lbytes (2 * n1 * n2)
-> i:size_nat{i < n1}
-> res:matrix n1 n2
-> matrix n1 n2
let frodo_sample_matrix1 a n1 n2 r i res =
Loops.repeati n2 (frodo_sample_matrix0 a n1 n2 r i) res
val frodo_sample_matrix:
a:frodo_alg
-> n1:size_nat
-> n2:size_nat{2 * n1 * n2 <= max_size_t}
-> r:lbytes (2 * n1 * n2)
-> matrix n1 n2 | {
"checked_file": "/",
"dependencies": [
"Spec.Matrix.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.Lemmas.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Sample.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Spec.Matrix",
"short_module": "Matrix"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Frodo.Params.frodo_alg ->
n1: Lib.IntTypes.size_nat ->
n2: Lib.IntTypes.size_nat{(2 * n1) * n2 <= Lib.IntTypes.max_size_t} ->
r: Lib.ByteSequence.lbytes ((2 * n1) * n2)
-> Spec.Matrix.matrix n1 n2 | Prims.Tot | [
"total"
] | [] | [
"Spec.Frodo.Params.frodo_alg",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Lib.ByteSequence.lbytes",
"Lib.LoopCombinators.repeati",
"Spec.Matrix.matrix",
"Spec.Frodo.Sample.frodo_sample_matrix1",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U16",
"Lib.IntTypes.SEC",
"Prims.op_Multiply",
"Spec.Matrix.create"
] | [] | false | false | false | false | false | let frodo_sample_matrix a n1 n2 r =
| let res = Matrix.create n1 n2 in
Loops.repeati n1 (frodo_sample_matrix1 a n1 n2 r) res | false |
Spec.Frodo.Sample.fst | Spec.Frodo.Sample.frodo_sample_matrix0 | val frodo_sample_matrix0:
a:frodo_alg
-> n1:size_nat
-> n2:size_nat{2 * n1 * n2 <= max_size_t}
-> r:lbytes (2 * n1 * n2)
-> i:size_nat{i < n1}
-> j:size_nat{j < n2}
-> res:matrix n1 n2
-> matrix n1 n2 | val frodo_sample_matrix0:
a:frodo_alg
-> n1:size_nat
-> n2:size_nat{2 * n1 * n2 <= max_size_t}
-> r:lbytes (2 * n1 * n2)
-> i:size_nat{i < n1}
-> j:size_nat{j < n2}
-> res:matrix n1 n2
-> matrix n1 n2 | let frodo_sample_matrix0 a n1 n2 r i j res =
lemma_matrix_index_repeati1 n1 n2 i j;
res.(i, j) <- frodo_sample a (uint_from_bytes_le (LSeq.sub r (2 * (i * n2 + j)) 2)) | {
"file_name": "specs/frodo/Spec.Frodo.Sample.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 85,
"end_line": 87,
"start_col": 0,
"start_line": 85
} | module Spec.Frodo.Sample
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Matrix
open Spec.Frodo.Lemmas
open Spec.Frodo.Params
module LSeq = Lib.Sequence
module Matrix = Spec.Matrix
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val frodo_sample_f:
a:frodo_alg
-> t:uint16
-> i:size_nat{i < cdf_table_len a}
-> res:nat{res = 0 \/ res = 1}
let frodo_sample_f a t i =
if v t > v (cdf_table a).[i] then 1 else 0
val frodo_sample_fc:
a:frodo_alg
-> t:uint16
-> i:size_nat{i <= cdf_table_len a}
-> GTot (res:nat{0 <= res /\ res <= i})
(decreases i)
let rec frodo_sample_fc a t i =
if i = 0 then 0
else frodo_sample_f a t (i - 1) + frodo_sample_fc a t (i - 1)
val frodo_sample_res:
a:frodo_alg
-> sign:uint16{v sign <= 1}
-> e:nat{e < cdf_table_len a}
-> uint16
let frodo_sample_res a r0 e =
let open FStar.Math.Lib in
let e = (powx (-1) (v r0)) * e in
assert_norm (powx (-1) 1 == -1);
assert_norm (powx (-1) 0 == 1);
assert (-cdf_table_len a < e /\ e < cdf_table_len a);
u16 (e % modulus U16)
#push-options "--fuel 1"
val frodo_sample: a:frodo_alg -> r:uint16 -> uint16
let frodo_sample a r =
let t = r >>. 1ul in
let r0 = r &. u16 1 in
mod_mask_lemma r 1ul;
assert (v #U16 #SEC (mod_mask 1ul) == 1);
assert (v r0 == 0 \/ v r0 == 1);
let e =
Loops.repeati_inductive
(cdf_table_len a - 1)
(fun z e -> 0 <= e /\ e <= z /\ e == frodo_sample_fc a t z)
(fun z e -> frodo_sample_f a t z + e) 0 in
frodo_sample_res a r0 e
#pop-options
// frodo_sample_matrix can be replaced with `creati`
val frodo_sample_matrix0:
a:frodo_alg
-> n1:size_nat
-> n2:size_nat{2 * n1 * n2 <= max_size_t}
-> r:lbytes (2 * n1 * n2)
-> i:size_nat{i < n1}
-> j:size_nat{j < n2}
-> res:matrix n1 n2
-> matrix n1 n2 | {
"checked_file": "/",
"dependencies": [
"Spec.Matrix.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.Lemmas.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked"
],
"interface_file": false,
"source_file": "Spec.Frodo.Sample.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Spec.Matrix",
"short_module": "Matrix"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Matrix",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"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": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Frodo.Params.frodo_alg ->
n1: Lib.IntTypes.size_nat ->
n2: Lib.IntTypes.size_nat{(2 * n1) * n2 <= Lib.IntTypes.max_size_t} ->
r: Lib.ByteSequence.lbytes ((2 * n1) * n2) ->
i: Lib.IntTypes.size_nat{i < n1} ->
j: Lib.IntTypes.size_nat{j < n2} ->
res: Spec.Matrix.matrix n1 n2
-> Spec.Matrix.matrix n1 n2 | Prims.Tot | [
"total"
] | [] | [
"Spec.Frodo.Params.frodo_alg",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.max_size_t",
"Lib.ByteSequence.lbytes",
"Prims.op_LessThan",
"Spec.Matrix.matrix",
"Spec.Matrix.op_Array_Assignment",
"FStar.Pervasives.Native.Mktuple2",
"Spec.Frodo.Sample.frodo_sample",
"Lib.ByteSequence.uint_from_bytes_le",
"Lib.IntTypes.U16",
"Lib.IntTypes.SEC",
"Lib.Sequence.sub",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Prims.op_Addition",
"Prims.unit",
"Spec.Frodo.Lemmas.lemma_matrix_index_repeati1"
] | [] | false | false | false | false | false | let frodo_sample_matrix0 a n1 n2 r i j res =
| lemma_matrix_index_repeati1 n1 n2 i j;
res.(i, j) <- frodo_sample a (uint_from_bytes_le (LSeq.sub r (2 * (i * n2 + j)) 2)) | false |
FStar.InteractiveHelpers.Base.fst | FStar.InteractiveHelpers.Base.deep_apply_subst_in_pattern | val deep_apply_subst_in_pattern : env -> pattern -> list (bv & term) -> Tac (pattern & list (bv & term)) | val deep_apply_subst_in_pattern : env -> pattern -> list (bv & term) -> Tac (pattern & list (bv & term)) | let rec deep_apply_subst e t subst =
match inspect t with
| Tv_Var b ->
begin match bind_map_get subst b with
| None -> t
| Some t' -> t'
end
| Tv_BVar b ->
(* Note: Tv_BVar shouldn't happen *)
begin match bind_map_get subst b with
| None -> t
| Some t' -> t'
end
| Tv_FVar _ -> t
| Tv_App hd (a,qual) ->
let hd = deep_apply_subst e hd subst in
let a = deep_apply_subst e a subst in
pack (Tv_App hd (a, qual))
| Tv_Abs br body ->
let body = deep_apply_subst e body subst in
pack (Tv_Abs br body)
| Tv_Arrow br c ->
let br, subst = deep_apply_subst_in_binder e br subst in
let c = deep_apply_subst_in_comp e c subst in
pack (Tv_Arrow br c)
| Tv_Type _ -> t
| Tv_Refine bv sort ref ->
let sort = deep_apply_subst e sort subst in
let bv, subst = deep_apply_subst_in_bv e bv subst in
let ref = deep_apply_subst e ref subst in
pack (Tv_Refine bv sort ref)
| Tv_Const _ -> t
| Tv_Uvar _ _ -> t
| Tv_Let recf attrs bv ty def body ->
(* No need to substitute in the attributes - that we filter for safety *)
let ty = deep_apply_subst e ty subst in
let def = deep_apply_subst e def subst in
let bv, subst = deep_apply_subst_in_bv e bv subst in
let body = deep_apply_subst e body subst in
pack (Tv_Let recf [] bv ty def body)
| Tv_Match scrutinee ret_opt branches -> (* TODO: type of pattern variables *)
let scrutinee = deep_apply_subst e scrutinee subst in
let ret_opt = map_opt (fun (b, asc) ->
let b, subst = deep_apply_subst_in_binder e b subst in
let asc =
match asc with
| Inl t, tacopt, use_eq ->
Inl (deep_apply_subst e t subst),
map_opt (fun tac -> deep_apply_subst e tac subst) tacopt,
use_eq
| Inr c, tacopt, use_eq ->
Inr (deep_apply_subst_in_comp e c subst),
map_opt (fun tac -> deep_apply_subst e tac subst) tacopt,
use_eq in
b, asc) ret_opt in
(* For the branches: we don't need to explore the patterns *)
let deep_apply_subst_in_branch branch =
let pat, tm = branch in
let pat, subst = deep_apply_subst_in_pattern e pat subst in
let tm = deep_apply_subst e tm subst in
pat, tm
in
let branches = map deep_apply_subst_in_branch branches in
pack (Tv_Match scrutinee ret_opt branches)
| Tv_AscribedT exp ty tac use_eq ->
let exp = deep_apply_subst e exp subst in
let ty = deep_apply_subst e ty subst in
(* no need to apply it on the tactic - that we filter for safety *)
pack (Tv_AscribedT exp ty None use_eq)
| Tv_AscribedC exp c tac use_eq ->
let exp = deep_apply_subst e exp subst in
let c = deep_apply_subst_in_comp e c subst in
(* no need to apply it on the tactic - that we filter for safety *)
pack (Tv_AscribedC exp c None use_eq)
| _ ->
(* Unknown *)
t
and deep_apply_subst_in_bv e bv subst =
(* No substitution needs to happen for variables
(there is no longer a sort). But, shift the substitution. *)
bv, (bv, pack (Tv_Var bv))::subst
(*
* AR: TODO: should apply subst in attrs?
*)
and deep_apply_subst_in_binder e br subst =
let open inspect_binder br <: binder_view in
let binder_sort = deep_apply_subst e binder_sort subst in
let binder_bv, subst = deep_apply_subst_in_bv e binder_bv subst in
pack_binder {
binder_bv=binder_bv;
binder_qual=binder_qual;
binder_attrs=binder_attrs;
binder_sort=binder_sort;
}, subst
and deep_apply_subst_in_comp e c subst =
let subst = (fun x -> deep_apply_subst e x subst) in
let subst_in_aqualv a : Tac aqualv =
match a with
| Q_Implicit
| Q_Explicit -> a
| Q_Meta t -> Q_Meta (subst t)
in
match inspect_comp c with
| C_Total ret ->
let ret = subst ret in
pack_comp (C_Total ret)
| C_GTotal ret ->
let ret = subst ret in
pack_comp (C_GTotal ret)
| C_Lemma pre post patterns ->
let pre = subst pre in
let post = subst post in
let patterns = subst patterns in
pack_comp (C_Lemma pre post patterns)
| C_Eff us eff_name result eff_args decrs ->
let result = subst result in
let eff_args = map (fun (x, a) -> (subst x, subst_in_aqualv a)) eff_args in
let decrs = map subst decrs in
pack_comp (C_Eff us eff_name result eff_args decrs)
and deep_apply_subst_in_pattern e pat subst =
match pat with
| Pat_Constant _ -> pat, subst
| Pat_Cons fv us patterns ->
(* The types of the variables in the patterns should be independent of each
* other: we use fold_left only to incrementally update the substitution *)
let patterns, subst =
fold_right (fun (pat, b) (pats, subst) ->
let pat, subst = deep_apply_subst_in_pattern e pat subst in
((pat, b) :: pats, subst)) patterns ([], subst)
in
Pat_Cons fv us patterns, subst
| Pat_Var bv st ->
let st = Sealed.seal (deep_apply_subst e (unseal st) subst) in
let bv, subst = deep_apply_subst_in_bv e bv subst in
Pat_Var bv st, subst
| Pat_Dot_Term eopt ->
Pat_Dot_Term (map_opt (fun t -> deep_apply_subst e t subst) eopt), subst | {
"file_name": "ulib/experimental/FStar.InteractiveHelpers.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 76,
"end_line": 575,
"start_col": 0,
"start_line": 435
} | module FStar.InteractiveHelpers.Base
open FStar.List
open FStar.Tactics
open FStar.Mul
#push-options "--z3rlimit 15 --fuel 0 --ifuel 1"
(*** Utilities *)
val bv_eq : bv -> bv -> Tot bool
let bv_eq (bv1 bv2 : bv) =
let bvv1 = inspect_bv bv1 in
let bvv2 = inspect_bv bv2 in
(* We don't check for type equality: the fact that no two different binders
* have the same name and index is an invariant which must be enforced -
* and actually we could limit ourselves to checking the index *)
bvv1.bv_index = bvv2.bv_index
val fv_eq : fv -> fv -> Tot bool
let fv_eq fv1 fv2 =
let n1 = inspect_fv fv1 in
let n2 = inspect_fv fv2 in
n1 = n2
// TODO: use everywhere
val fv_eq_name : fv -> name -> Tot bool
let fv_eq_name fv n =
let fvn = inspect_fv fv in
fvn = n
// TODO: use more
val opt_apply (#a #b : Type) (f : a -> Tot b) (x : option a) : Tot (option b)
let opt_apply #a #b f x =
match x with
| None -> None
| Some x' -> Some (f x')
val opt_tapply (#a #b : Type) (f : a -> Tac b) (x : option a) : Tac (option b)
let opt_tapply #a #b f x =
match x with
| None -> None
| Some x' -> Some (f x')
val option_to_string : (#a : Type) -> (a -> Tac string) -> option a -> Tac string
let option_to_string #a f x =
match x with
| None -> "None"
| Some x' -> "Some (" ^ f x' ^ ")"
let opt_cons (#a : Type) (opt_x : option a) (ls : list a) : Tot (list a) =
match opt_x with
| Some x -> x :: ls
| None -> ls
val list_to_string : #a : Type -> (a -> Tac string) -> list a -> Tac string
let list_to_string #a f ls =
(Tactics.Util.fold_left (fun s x -> s ^ " (" ^ f x ^ ");") "[" ls) ^ "]"
/// Apply a term to a list of parameters, normalize the result to make sure
/// all the abstractions are simplified
val mk_app_norm : env -> term -> list term -> Tac term
let mk_app_norm e t params =
let t1 = mk_e_app t params in
let t2 = norm_term_env e [] t1 in
t2
val opt_mk_app_norm : env -> option term -> list term -> Tac (option term)
let opt_mk_app_norm e opt_t params =
opt_tapply (fun t -> mk_app_norm e t params) opt_t
// TODO: remove
let rec unzip #a #b (l : list (a & b)) : Tot (list a & list b) =
match l with
| [] -> ([],[])
| (hd1,hd2)::tl ->
let (tl1,tl2) = unzip tl in
(hd1::tl1,hd2::tl2)
/// Alternative ``bv_to_string`` function where we print the index of the bv.
/// It can be very useful for debugging.
let abv_to_string bv : Tac string =
let bvv = inspect_bv bv in
name_of_bv bv ^ " (%" ^ string_of_int (bvv.bv_index) ^ ")"
let print_binder_info (full : bool) (b : binder) : Tac unit =
let open inspect_binder b <: binder_view in
let qual_str = match binder_qual with
| Q_Implicit -> "Implicit"
| Q_Explicit -> "Explicit"
| Q_Meta t -> "Meta: " ^ term_to_string t
in
let bview = inspect_bv binder_bv in
if full then
print (
"> print_binder_info:" ^
"\n- name: " ^ (name_of_binder b) ^
"\n- as string: " ^ (binder_to_string b) ^
"\n- aqual: " ^ qual_str ^
"\n- ppname: " ^ name_of_bv binder_bv ^
"\n- index: " ^ string_of_int bview.bv_index ^
"\n- sort: " ^ term_to_string binder_sort
)
else print (binder_to_string b)
let print_binders_info (full : bool) (e:env) : Tac unit =
iter (print_binder_info full) (binders_of_env e)
let acomp_to_string (c:comp) : Tac string =
match inspect_comp c with
| C_Total ret ->
"C_Total (" ^ term_to_string ret ^ ")"
| C_GTotal ret ->
"C_GTotal (" ^ term_to_string ret ^ ")"
| C_Lemma pre post patterns ->
"C_Lemma (" ^ term_to_string pre ^ ") (" ^ term_to_string post ^ ")"
| C_Eff us eff_name result eff_args _ ->
let eff_arg_to_string (a : term) : Tac string =
" (" ^ term_to_string a ^ ")"
in
let args_str = map (fun (x, y) -> eff_arg_to_string x) eff_args in
let args_str = List.Tot.fold_left (fun x y -> x ^ y) "" args_str in
"C_Eff (" ^ flatten_name eff_name ^ ") (" ^ term_to_string result ^ ")" ^ args_str
exception MetaAnalysis of string
let mfail str =
raise (MetaAnalysis str)
(*** Debugging *)
/// Some debugging facilities
val print_dbg : bool -> string -> Tac unit
let print_dbg debug s =
if debug then print s
/// Return the qualifier of a term as a string
val term_view_construct (t : term_view) : Tac string
let term_view_construct (t : term_view) : Tac string =
match t with
| Tv_Var _ -> "Tv_Var"
| Tv_BVar _ -> "Tv_BVar"
| Tv_FVar _ -> "Tv_FVar"
| Tv_App _ _ -> "Tv_App"
| Tv_Abs _ _ -> "Tv_Abs"
| Tv_Arrow _ _ -> "Tv_Arrow"
| Tv_Type _ -> "Tv_Type"
| Tv_Refine _ _ _ -> "Tv_Refine"
| Tv_Const _ -> "Tv_Const"
| Tv_Uvar _ _ -> "Tv_Uvar"
| Tv_Let _ _ _ _ _ _ -> "Tv_Let"
| Tv_Match _ _ _ -> "Tv_Match"
| Tv_AscribedT _ _ _ _ -> "Tv_AscribedT"
| Tv_AscribedC _ _ _ _ -> "Tv_AScribedC"
| _ -> "Tv_Unknown"
val term_construct (t : term) : Tac string
let term_construct (t : term) : Tac string =
term_view_construct (inspect t)
(*** Pretty printing *)
/// There are many issues linked to terms (pretty) printing.
/// The first issue is that when parsing terms, F* automatically inserts
/// ascriptions, which then clutter the terms printed to the user. The current
/// workaround is to filter those ascriptions in the terms before exploiting them.
/// TODO: this actually doesn't work for some unknown reason: some terms like [a /\ b]
/// become [l_and a b]...
val filter_ascriptions : bool -> term -> Tac term
let filter_ascriptions dbg t =
print_dbg dbg ("[> filter_ascriptions: " ^ term_view_construct t ^ ": " ^ term_to_string t );
visit_tm (fun t ->
match inspect t with
| Tv_AscribedT e _ _ _
| Tv_AscribedC e _ _ _ -> e
| _ -> t) t
/// Our prettification function. Apply it to all the terms which might be printed
/// back to the user. Note that the time at which the function is applied is
/// important: we can't apply it on all the assertions we export to the user, just
/// before exporting, because we may have inserted ascriptions on purpose, which
/// would then be filtered away.
val prettify_term : bool -> term -> Tac term
let prettify_term dbg t = filter_ascriptions dbg t
(*** Environments *)
/// We need a way to handle environments with variable bindings
/// and name shadowing, to properly display the context to the user.
/// A map linking variables to terms. For now we use a list to define it, because
/// there shouldn't be too many bindings.
type bind_map (a : Type) = list (bv & a)
let bind_map_push (#a:Type) (m:bind_map a) (b:bv) (x:a) = (b,x)::m
let rec bind_map_get (#a:Type) (m:bind_map a) (b:bv) : Tot (option a) =
match m with
| [] -> None
| (b', x)::m' ->
if compare_bv b b' = Order.Eq then Some x else bind_map_get m' b
let rec bind_map_get_from_name (#a:Type) (m:bind_map a) (name:string) :
Tac (option (bv & a)) =
match m with
| [] -> None
| (b', x)::m' ->
let b'v = inspect_bv b' in
if unseal b'v.bv_ppname = name then Some (b', x) else bind_map_get_from_name m' name
noeq type genv =
{
env : env;
(* Whenever we evaluate a let binding, we keep track of the relation between
* the binder and its definition.
* The boolean indicates whether or not the variable is considered abstract. We
* often need to introduce variables which don't appear in the user context, for
* example when we need to deal with a postcondition for Stack or ST, which handles
* the previous and new memory states, and which may not be available in the user
* context, or where we don't always know which variable to use.
* In this case, whenever we output the term, we write its content as an
* abstraction applied to those missing parameters. For instance, in the
* case of the assertion introduced for a post-condition:
* [> assert((fun h1 h2 -> post) h1 h2);
* Besides the informative goal, the user can replace those parameters (h1
* and h2 above) by the proper ones then normalize the assertion by using
* the appropriate command to get a valid assertion. *)
bmap : bind_map (typ & bool & term);
(* Whenever we introduce a new variable, we check whether it shadows another
* variable because it has the same name, and put it in the below
* list. Of course, for the F* internals such shadowing is not an issue, because
* the index of every variable should be different, but this is very important
* when generating code for the user *)
svars : list (bv & typ);
}
let get_env (e:genv) : env = e.env
let get_bind_map (e:genv) : bind_map (typ & bool & term) = e.bmap
let mk_genv env bmap svars : genv = Mkgenv env bmap svars
let mk_init_genv env : genv = mk_genv env [] []
val genv_to_string : genv -> Tac string
let genv_to_string ge =
let binder_to_string (b : binder) : Tac string =
abv_to_string (bv_of_binder b) ^ "\n"
in
let binders_str = map binder_to_string (binders_of_env ge.env) in
let bmap_elem_to_string (e : bv & (typ & bool & term)) : Tac string =
let bv, (_sort, abs, t) = e in
"(" ^ abv_to_string bv ^" -> (" ^
string_of_bool abs ^ ", " ^ term_to_string t ^ "))\n"
in
let bmap_str = map bmap_elem_to_string ge.bmap in
let svars_str = map (fun (bv, _) -> abv_to_string bv ^ "\n") ge.svars in
let flatten = List.Tot.fold_left (fun x y -> x ^ y) "" in
"> env:\n" ^ flatten binders_str ^
"> bmap:\n" ^ flatten bmap_str ^
"> svars:\n" ^ flatten svars_str
let genv_get (ge:genv) (b:bv) : Tot (option (typ & bool & term)) =
bind_map_get ge.bmap b
let genv_get_from_name (ge:genv) (name:string) : Tac (option ((bv & typ) & (bool & term))) =
(* tweak return a bit to include sort *)
match bind_map_get_from_name ge.bmap name with
| None -> None
| Some (bv, (sort, b, x)) -> Some ((bv, sort), (b, x))
/// Push a binder to a ``genv``. Optionally takes a ``term`` which provides the
/// term the binder is bound to (in a `let _ = _ in` construct for example).
let genv_push_bv (ge:genv) (b:bv) (sort:typ) (abs:bool) (t:option term) : Tac genv =
let br = mk_binder b sort in
let sv = genv_get_from_name ge (name_of_bv b) in
let svars' = if Some? sv then fst (Some?.v sv) :: ge.svars else ge.svars in
let e' = push_binder ge.env br in
let tm = if Some? t then Some?.v t else pack (Tv_Var b) in
let bmap' = bind_map_push ge.bmap b (sort, abs, tm) in
mk_genv e' bmap' svars'
let genv_push_binder (ge:genv) (b:binder) (abs:bool) (t:option term) : Tac genv =
genv_push_bv ge (bv_of_binder b) (binder_sort b) abs t
/// Check if a binder is shadowed by another more recent binder
let bv_is_shadowed (ge : genv) (bv : bv) : Tot bool =
List.Tot.existsb (fun (b,_) -> bv_eq bv b) ge.svars
let binder_is_shadowed (ge : genv) (b : binder) : Tot bool =
bv_is_shadowed ge (bv_of_binder b)
let find_shadowed_bvs (ge : genv) (bl : list bv) : Tot (list (bv & bool)) =
List.Tot.map (fun b -> b, bv_is_shadowed ge b) bl
let find_shadowed_binders (ge : genv) (bl : list binder) : Tot (list (binder & bool)) =
List.Tot.map (fun b -> b, binder_is_shadowed ge b) bl
val bv_is_abstract : genv -> bv -> Tot bool
let bv_is_abstract ge bv =
match genv_get ge bv with
| None -> false
| Some (_, abs, _) -> abs
val binder_is_abstract : genv -> binder -> Tot bool
let binder_is_abstract ge b =
bv_is_abstract ge (bv_of_binder b)
val genv_abstract_bvs : genv -> Tot (list (bv & typ))
let genv_abstract_bvs ge =
List.Tot.concatMap
(fun (bv, (ty, abs, _)) -> if abs then [bv,ty] else []) ge.bmap
/// Versions of ``fresh_bv`` and ``fresh_binder`` inspired by the standard library
/// We make sure the name is fresh because we need to be able to generate valid code
/// (it is thus not enough to have a fresh integer).
let rec _fresh_bv binder_names basename i : Tac bv =
let name = basename ^ string_of_int i in
(* In worst case the performance is quadratic in the number of binders.
* TODO: fix that, it actually probably happens for anonymous variables ('_') *)
if List.mem name binder_names then _fresh_bv binder_names basename (i+1)
else fresh_bv_named name
let fresh_bv (e : env) (basename : string) : Tac bv =
let binders = binders_of_env e in
let binder_names = Tactics.map name_of_binder binders in
_fresh_bv binder_names basename 0
let fresh_binder (e : env) (basename : string) (ty : typ) : Tac binder =
let bv = fresh_bv e basename in
mk_binder bv ty
let genv_push_fresh_binder (ge : genv) (basename : string) (ty : typ) : Tac (genv & binder) =
let b = fresh_binder ge.env basename ty in
(* TODO: we can have a shortcircuit push (which performs less checks) *)
let ge' = genv_push_binder ge b true None in
ge', b
// TODO: actually we should use push_fresh_bv more
let push_fresh_binder (e : env) (basename : string) (ty : typ) : Tac (env & binder) =
let b = fresh_binder e basename ty in
let e' = push_binder e b in
e', b
let genv_push_fresh_bv (ge : genv) (basename : string) (ty : typ) : Tac (genv & bv) =
let ge', b = genv_push_fresh_binder ge basename ty in
ge', bv_of_binder b
val push_fresh_var : env -> string -> typ -> Tac (term & binder & env)
let push_fresh_var e0 basename ty =
let e1, b1 = push_fresh_binder e0 basename ty in
let v1 = pack (Tv_Var (bv_of_binder b1)) in
v1, b1, e1
val genv_push_fresh_var : genv -> string -> typ -> Tac (term & binder & genv)
let genv_push_fresh_var ge0 basename ty =
let ge1, b1 = genv_push_fresh_binder ge0 basename ty in
let v1 = pack (Tv_Var (bv_of_binder b1)) in
v1, b1, ge1
val push_two_fresh_vars : env -> string -> typ -> Tac (term & binder & term & binder & env)
let push_two_fresh_vars e0 basename ty =
let e1, b1 = push_fresh_binder e0 basename ty in
let e2, b2 = push_fresh_binder e1 basename ty in
let v1 = pack (Tv_Var (bv_of_binder b1)) in
let v2 = pack (Tv_Var (bv_of_binder b2)) in
v1, b1, v2, b2, e2
val genv_push_two_fresh_vars : genv -> string -> typ -> Tac (term & binder & term & binder & genv)
let genv_push_two_fresh_vars ge0 basename ty =
let ge1, b1 = genv_push_fresh_binder ge0 basename ty in
let ge2, b2 = genv_push_fresh_binder ge1 basename ty in
let v1 = pack (Tv_Var (bv_of_binder b1)) in
let v2 = pack (Tv_Var (bv_of_binder b2)) in
v1, b1, v2, b2, ge2
(*** Substitutions *)
/// Substitutions
/// Custom substitutions using the normalizer. This is the easiest and safest
/// way to perform a substitution: if you want to substitute [v] with [t] in [exp],
/// just normalize [(fun v -> exp) t]. Note that this may be computationally expensive.
val norm_apply_subst : env -> term -> list ((bv & typ) & term) -> Tac term
val norm_apply_subst_in_comp : env -> comp -> list ((bv & typ) & term) -> Tac comp
let norm_apply_subst e t subst =
let bl, vl = unzip subst in
let bl = List.Tot.map (fun (bv,ty) -> mk_binder bv ty) bl in
let t1 = mk_abs bl t in
let t2 = mk_e_app t1 vl in
norm_term_env e [] t2
let norm_apply_subst_in_comp e c subst =
let subst = (fun x -> norm_apply_subst e x subst) in
let subst_in_aqualv a : Tac aqualv =
match a with
| Q_Implicit
| Q_Explicit -> a
| Q_Meta t -> Q_Meta (subst t)
in
match inspect_comp c with
| C_Total ret ->
let ret = subst ret in
pack_comp (C_Total ret)
| C_GTotal ret ->
let ret = subst ret in
pack_comp (C_GTotal ret)
| C_Lemma pre post patterns ->
let pre = subst pre in
let post = subst post in
let patterns = subst patterns in
pack_comp (C_Lemma pre post patterns)
| C_Eff us eff_name result eff_args decrs ->
let result = subst result in
let eff_args = map (fun (x, a) -> (subst x, subst_in_aqualv a)) eff_args in
let decrs = map subst decrs in
pack_comp (C_Eff us eff_name result eff_args decrs)
/// As substitution with normalization is very expensive, we implemented another
/// technique which works by exploring terms. This is super fast, but the terms
/// seem not to be reconstructed in the same way, which has a big impact on pretty printing.
/// For example, terms like [A /\ B] get printed as [Prims.l_and A B].
val deep_apply_subst : env -> term -> list (bv & term) -> Tac term
// Whenever we encounter a construction which introduces a binder, we need to apply
// the substitution in the binder type. Note that this gives a new binder, with
// which we need to replace the old one in what follows.
// Also note that it should be possible to rewrite [deep_apply_subst] in terms of [visit_tm],
// but [deep_apply_subst] seems to be a bit more precise with regard to type replacements (not
// sure it is really important, though).
val deep_apply_subst_in_bv : env -> bv -> list (bv & term) -> Tac (bv & list (bv & term))
val deep_apply_subst_in_binder : env -> binder -> list (bv & term) -> Tac (binder & list (bv & term))
val deep_apply_subst_in_comp : env -> comp -> list (bv & term) -> Tac comp
val deep_apply_subst_in_pattern : env -> pattern -> list (bv & term) -> Tac (pattern & list (bv & term)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.Util.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Order.fst.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked"
],
"interface_file": false,
"source_file": "FStar.InteractiveHelpers.Base.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.InteractiveHelpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.InteractiveHelpers",
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 15,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
e: FStar.Stubs.Reflection.Types.env ->
pat: FStar.Stubs.Reflection.V1.Data.pattern ->
subst: Prims.list (FStar.Stubs.Reflection.Types.bv * FStar.Stubs.Reflection.Types.term)
-> FStar.Tactics.Effect.Tac
(FStar.Stubs.Reflection.V1.Data.pattern *
Prims.list (FStar.Stubs.Reflection.Types.bv * FStar.Stubs.Reflection.Types.term)) | FStar.Tactics.Effect.Tac | [] | [
"deep_apply_subst",
"deep_apply_subst_in_bv",
"deep_apply_subst_in_binder",
"deep_apply_subst_in_comp",
"deep_apply_subst_in_pattern"
] | [
"FStar.Stubs.Reflection.Types.env",
"FStar.Stubs.Reflection.V1.Data.pattern",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"FStar.Stubs.Reflection.Types.bv",
"FStar.Stubs.Reflection.Types.term",
"FStar.Stubs.Reflection.V1.Data.vconst",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Stubs.Reflection.Types.fv",
"FStar.Pervasives.Native.option",
"FStar.Stubs.Reflection.V1.Data.universes",
"Prims.bool",
"FStar.Stubs.Reflection.V1.Data.Pat_Cons",
"FStar.Tactics.Util.fold_right",
"Prims.Cons",
"FStar.InteractiveHelpers.Base.deep_apply_subst_in_pattern",
"Prims.Nil",
"FStar.Sealed.sealed",
"FStar.Stubs.Reflection.Types.typ",
"FStar.Stubs.Reflection.V1.Data.Pat_Var",
"FStar.InteractiveHelpers.Base.deep_apply_subst_in_bv",
"FStar.Sealed.seal",
"FStar.InteractiveHelpers.Base.deep_apply_subst",
"FStar.Tactics.Unseal.unseal",
"FStar.Stubs.Reflection.V1.Data.Pat_Dot_Term",
"FStar.Tactics.Util.map_opt"
] | [
"mutual recursion"
] | false | true | false | false | false | let rec deep_apply_subst_in_pattern e pat subst =
| match pat with
| Pat_Constant _ -> pat, subst
| Pat_Cons fv us patterns ->
let patterns, subst =
fold_right (fun (pat, b) (pats, subst) ->
let pat, subst = deep_apply_subst_in_pattern e pat subst in
((pat, b) :: pats, subst))
patterns
([], subst)
in
Pat_Cons fv us patterns, subst
| Pat_Var bv st ->
let st = Sealed.seal (deep_apply_subst e (unseal st) subst) in
let bv, subst = deep_apply_subst_in_bv e bv subst in
Pat_Var bv st, subst
| Pat_Dot_Term eopt -> Pat_Dot_Term (map_opt (fun t -> deep_apply_subst e t subst) eopt), subst | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.flip | val flip (#a #b: Type) (c: (a * b)) : Tot (b * a) | val flip (#a #b: Type) (c: (a * b)) : Tot (b * a) | let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca) | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 80,
"end_line": 43,
"start_col": 0,
"start_line": 43
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } ) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | c: (a * b) -> b * a | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2"
] | [] | false | false | false | true | false | let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) =
| let ca, cb = c in
(cb, ca) | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.list_mem | val list_mem (#t: eqtype) (x: t) (l: list t) : Tot (y: bool{y == true <==> L.mem x l == true}) | val list_mem (#t: eqtype) (x: t) (l: list t) : Tot (y: bool{y == true <==> L.mem x l == true}) | let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q) | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 37,
"end_line": 29,
"start_col": 0,
"start_line": 22
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
}) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | x: t -> l: Prims.list t -> y: Prims.bool{y == true <==> FStar.List.Tot.Base.mem x l == true} | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"Prims.list",
"Prims.op_BarBar",
"Prims.op_Equality",
"LowParse.Spec.Enum.list_mem",
"Prims.bool",
"Prims.l_iff",
"Prims.eq2",
"FStar.List.Tot.Base.mem"
] | [
"recursion"
] | false | false | false | false | false | let rec list_mem (#t: eqtype) (x: t) (l: list t) : Tot (y: bool{y == true <==> L.mem x l == true}) =
| match l with
| [] -> false
| a :: q -> (x = a || list_mem x q) | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.make_enum_key | val make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key)
: Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key))) | val make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key)
: Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key))) | let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 38,
"start_col": 0,
"start_line": 35
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } ) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | e: LowParse.Spec.Enum.enum key repr -> k: key -> Prims.Pure (LowParse.Spec.Enum.enum_key e) | Prims.Pure | [] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.enum_key",
"Prims.b2t",
"LowParse.Spec.Enum.list_mem",
"LowParse.Spec.Enum.list_map",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.fst",
"Prims.eq2"
] | [] | false | false | false | false | false | let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key)
: Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key))) =
| k | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.list_map | val list_map (#a #b: Type) (f: (a -> Tot b)) (l: list a) : Tot (l': list b {l' == L.map f l}) | val list_map (#a #b: Type) (f: (a -> Tot b)) (l: list a) : Tot (l': list b {l' == L.map f l}) | let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 33,
"end_line": 14,
"start_col": 0,
"start_line": 7
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | f: (_: a -> b) -> l: Prims.list a -> l': Prims.list b {l' == FStar.List.Tot.Base.map f l} | Prims.Tot | [
"total"
] | [] | [
"Prims.list",
"Prims.Nil",
"Prims.Cons",
"LowParse.Spec.Enum.list_map",
"Prims.eq2",
"FStar.List.Tot.Base.map"
] | [
"recursion"
] | false | false | false | false | false | let rec list_map (#a #b: Type) (f: (a -> Tot b)) (l: list a) : Tot (l': list b {l' == L.map f l}) =
| match l with
| [] -> []
| a :: q -> f a :: list_map f q | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.parse_enum_key_cond | val parse_enum_key_cond (#key #repr: eqtype) (e: enum key repr) (r: repr) : GTot bool | val parse_enum_key_cond (#key #repr: eqtype) (e: enum key repr) (r: repr) : GTot bool | let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e) | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 29,
"end_line": 146,
"start_col": 0,
"start_line": 141
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | e: LowParse.Spec.Enum.enum key repr -> r: repr -> Prims.GTot Prims.bool | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.list_mem",
"LowParse.Spec.Enum.list_map",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.snd",
"Prims.bool"
] | [] | false | false | false | false | false | let parse_enum_key_cond (#key #repr: eqtype) (e: enum key repr) (r: repr) : GTot bool =
| list_mem r (list_map snd e) | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.enum_repr | val enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype | val enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype | let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } ) | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 111,
"end_line": 41,
"start_col": 0,
"start_line": 41
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | e: LowParse.Spec.Enum.enum key repr -> Prims.eqtype | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.b2t",
"LowParse.Spec.Enum.list_mem",
"LowParse.Spec.Enum.list_map",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.snd"
] | [] | false | false | false | false | false | let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype =
| (r: repr{list_mem r (list_map snd e)}) | false |
Steel.ST.C.Types.Union.fsti | Steel.ST.C.Types.Union.union_switch_field | val union_switch_field:
#tn: Type0 ->
#tf: Type0 ->
#n: string ->
#fields: field_description_t tf ->
#v: Ghost.erased (union_t0 tn n fields) ->
r: ref (union0 tn n fields) ->
field: field_t fields ->
#t': Type0 ->
#td': typedef t' ->
(#[norm_fields ()] sq_t': squash (t' == fields.fd_type field)) ->
(#[norm_fields ()] sq_td': squash (td' == fields.fd_typedef field)) ->
Prims.unit
-> ST (ref td')
(pts_to r v)
(fun r' -> (has_union_field r field r') `star` (pts_to r' (uninitialized td')))
(full (union0 tn n fields) v)
(fun r' -> True) | val union_switch_field:
#tn: Type0 ->
#tf: Type0 ->
#n: string ->
#fields: field_description_t tf ->
#v: Ghost.erased (union_t0 tn n fields) ->
r: ref (union0 tn n fields) ->
field: field_t fields ->
#t': Type0 ->
#td': typedef t' ->
(#[norm_fields ()] sq_t': squash (t' == fields.fd_type field)) ->
(#[norm_fields ()] sq_td': squash (td' == fields.fd_typedef field)) ->
Prims.unit
-> ST (ref td')
(pts_to r v)
(fun r' -> (has_union_field r field r') `star` (pts_to r' (uninitialized td')))
(full (union0 tn n fields) v)
(fun r' -> True) | let union_switch_field
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields)
(#t': Type0)
(#td': typedef t')
(# [ norm_fields () ] sq_t': squash (t' == fields.fd_type field))
(# [ norm_fields () ] sq_td': squash (td' == fields.fd_typedef field))
()
: ST (ref td') // need to write the pcm carrier value, so this cannot be Ghost or Atomic
(pts_to r v)
(fun r' -> has_union_field r field r' `star` pts_to r' (uninitialized td'))
(full (union0 tn n fields) v)
(fun r' -> True)
= union_switch_field0
t'
r
field
td' | {
"file_name": "lib/steel/c/Steel.ST.C.Types.Union.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 7,
"end_line": 525,
"start_col": 0,
"start_line": 503
} | module Steel.ST.C.Types.Union
open Steel.ST.Util
include Steel.ST.C.Types.Fields
open Steel.C.Typestring
module P = Steel.FractionalPermission
[@@noextract_to "krml"] // primitive
val define_union0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot Type0
inline_for_extraction [@@noextract_to "krml"]
let define_union (n: string) (#tf: Type0) (#tn: Type0) (#[solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Tot Type0
= define_union0 tn #tf n fields
// To be extracted as: union t
[@@noextract_to "krml"] // primitive
val union_t0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot Type0
inline_for_extraction [@@noextract_to "krml"]
let union_t (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Tot Type0
= union_t0 tn #tf n fields
val union_set_field (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) (f: field_t fields) (v: fields.fd_type f) : GTot (union_t0 tn n fields)
val union_get_case
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(u: union_t0 tn n fields)
: GTot (option (field_t fields))
val union_get_field
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(u: union_t0 tn n fields)
(field: field_t fields)
: Ghost (fields.fd_type field)
(requires (union_get_case u == Some field))
(ensures (fun _ -> True))
val union_get_field_same
(tn: Type0)
(#tf: Type0)
(n: string)
(fields: field_description_t tf)
(field: field_t fields)
(v: fields.fd_type field)
: Lemma
(requires (~ (v == unknown (fields.fd_typedef field))))
(ensures (
let u = union_set_field tn n fields field v in
union_get_case u == Some field /\
union_get_field u field == v
))
[SMTPatOr [
[SMTPat (union_get_case (union_set_field tn n fields field v))];
[SMTPat (union_get_field (union_set_field tn n fields field v) field)];
]]
val union_set_field_same
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(s: union_t0 tn n fields)
(field: field_t fields)
: Lemma
(requires (union_get_case s == Some field))
(ensures (
union_set_field tn n fields field (union_get_field s field) == s
))
[SMTPat (union_set_field tn n fields (union_get_field s field))]
[@@noextract_to "krml"] // proof-only
val union0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot (typedef (union_t0 tn n fields))
inline_for_extraction
[@@noextract_to "krml"; norm_field_attr] // proof-only
let union (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Tot (typedef (union_t0 tn n fields))
= union0 tn #tf n fields
val union_get_case_unknown
(tn: Type0)
(#tf: Type0)
(n: string)
(fields: field_description_t tf)
: Lemma
(union_get_case (unknown (union0 tn n fields)) == None)
[SMTPat (unknown (union0 tn n fields))]
val union_set_field_unknown
(tn: Type0)
(#tf: Type0)
(n: string)
(fields: field_description_t tf)
(field: field_t fields)
: Lemma
(union_set_field tn n fields field (unknown (fields.fd_typedef field)) == unknown (union0 tn n fields))
[SMTPat (union_set_field tn n fields field (unknown (fields.fd_typedef field)))]
val union_get_case_uninitialized
(tn: Type0)
(#tf: Type0)
(n: string)
(fields: field_description_t tf)
: Lemma
(union_get_case (uninitialized (union0 tn n fields)) == None)
[SMTPat (uninitialized (union0 tn n fields))]
val mk_fraction_union_get_case
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(s: union_t0 tn n fields)
(p: P.perm)
: Lemma
(requires (fractionable (union0 tn n fields) s))
(ensures (
union_get_case (mk_fraction (union0 tn n fields) s p) == union_get_case s
))
[SMTPat (union_get_case (mk_fraction (union0 tn n fields) s p))]
val fractionable_union_get_field
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(s: union_t0 tn n fields)
(field: field_t fields)
: Lemma
(requires (union_get_case s == Some field))
(ensures (
fractionable (union0 tn n fields) s <==> fractionable (fields.fd_typedef field) (union_get_field s field)
))
[SMTPat (fractionable (union0 tn n fields) s); SMTPat (union_get_field s field)]
val mk_fraction_union_get_field
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(s: union_t0 tn n fields)
(p: P.perm)
(field: field_t fields)
: Lemma
(requires (fractionable (union0 tn n fields) s /\ union_get_case s == Some field))
(ensures (union_get_field (mk_fraction (union0 tn n fields) s p) field == mk_fraction (fields.fd_typedef field) (union_get_field s field) p))
[SMTPat (union_get_field (mk_fraction (union0 tn n fields) s p) field)]
val mk_fraction_union_set_field
(tn: Type0)
(#tf: Type0)
(n: string)
(fields: field_description_t tf)
(field: field_t fields)
(v: fields.fd_type field)
(p: P.perm)
: Lemma
(requires (fractionable (fields.fd_typedef field) v))
(ensures (
fractionable (union0 tn n fields) (union_set_field tn n fields field v) /\
mk_fraction (union0 tn n fields) (union_set_field tn n fields field v) p == union_set_field tn n fields field (mk_fraction (fields.fd_typedef field) v p)
))
val full_union
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(s: union_t0 tn n fields)
(field: field_t fields)
: Lemma
(requires (union_get_case s == Some field))
(ensures (
full (union0 tn n fields) s <==> full (fields.fd_typedef field) (union_get_field s field)
))
[SMTPat (full (union0 tn n fields) s); SMTPat (union_get_field s field)]
let full_union_set_field_intro
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(field: field_t fields)
(v: fields.fd_type field)
: Lemma
(requires (full (fields.fd_typedef field) v))
(ensures (
full (union0 tn n fields) (union_set_field tn n fields field v)
))
= full_union (union_set_field tn n fields field v) field
let full_union_set_field_elim
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(field: field_t fields)
(v: fields.fd_type field)
: Lemma
(requires (
full (union0 tn n fields) (union_set_field tn n fields field v)
))
(ensures (
full (fields.fd_typedef field) v
))
= full_union (union_set_field tn n fields field v) field
let full_union_set_field
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(field: field_t fields)
(v: fields.fd_type field)
: Lemma
(requires True)
(ensures (
full (union0 tn n fields) (union_set_field tn n fields field v) <==> full (fields.fd_typedef field) v
))
[SMTPat (full (union0 tn n fields) (union_set_field tn n fields field v))]
= Classical.move_requires (full_union_set_field_intro #tn #tf #n #fields field) v;
Classical.move_requires (full_union_set_field_elim #tn #tf #n #fields field) v
val has_union_field
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(r: ref (union0 tn n fields))
(field: field_t fields)
(#t': Type0)
(#td': typedef t')
(r': ref td')
: Tot vprop
val has_union_field_prop
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(r: ref (union0 tn n fields))
(field: field_t fields)
(#t': Type0)
(#td': typedef t')
(r': ref td')
: STGhost unit opened
(has_union_field r field r')
(fun _ -> has_union_field r field r')
True
(fun _ ->
t' == fields.fd_type field /\
td' == fields.fd_typedef field
)
val has_union_field_dup
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: nonempty_field_description_t tf)
(r: ref (union0 tn n fields))
(field: field_t fields)
(#t': Type0)
(#td': typedef t')
(r': ref td')
: STGhostT unit opened
(has_union_field r field r')
(fun _ -> has_union_field r field r' `star` has_union_field r field r')
val has_union_field_inj
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: nonempty_field_description_t tf)
(r: ref (union0 tn n fields))
(field: field_t fields)
(#t1: Type0)
(#td1: typedef t1)
(r1: ref td1)
(#t2: Type0)
(#td2: typedef t2)
(r2: ref td2)
: STGhostT (squash (t1 == t2 /\ td1 == td2)) opened
(has_union_field r field r1 `star` has_union_field r field r2)
(fun _ -> has_union_field r field r1 `star` has_union_field r field r2 `star` ref_equiv r1 (coerce_eq () r2))
val has_union_field_equiv_from
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: nonempty_field_description_t tf)
(r1 r2: ref (union0 tn n fields))
(field: field_t fields)
(#t': Type0)
(#td': typedef t')
(r': ref td')
: STGhostT unit opened
(has_union_field r1 field r' `star` ref_equiv r1 r2)
(fun _ -> has_union_field r2 field r' `star` ref_equiv r1 r2)
val has_union_field_equiv_to
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: nonempty_field_description_t tf)
(r: ref (union0 tn n fields))
(field: field_t fields)
(#t': Type0)
(#td': typedef t')
(r1 r2: ref td')
: STGhostT unit opened
(has_union_field r field r1 `star` ref_equiv r1 r2)
(fun _ -> has_union_field r field r2 `star` ref_equiv r1 r2)
val ghost_union_field_focus
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields {union_get_case v == Some field})
(#t': Type0)
(#td': typedef t')
(r': ref td')
: STGhostT (squash (
t' == fields.fd_type field /\
td' == fields.fd_typedef field
)) opened
(has_union_field r field r' `star` pts_to r v)
(fun _ -> has_union_field r field r' `star` pts_to r' (Ghost.hide (coerce_eq () (union_get_field v field))))
val ghost_union_field
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields {union_get_case v == Some field})
: STGhostT (Ghost.erased (ref (fields.fd_typedef field))) opened
(pts_to r v)
(fun r' -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
[@@noextract_to "krml"] // primitive
val union_field0
(#tn: Type0)
(#tf: Type0)
(t': Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields {union_get_case v == Some field})
(td': typedef t' {
t' == fields.fd_type field /\
td' == fields.fd_typedef field
})
: STT (ref td')
(pts_to r v)
(fun r' -> has_union_field r field r' `star` pts_to r' (Ghost.hide (coerce_eq () (union_get_field v field))))
inline_for_extraction [@@noextract_to "krml"]
let union_field1
(#tn: Type0)
(#tf: Type0)
(t': Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields {union_get_case v == Some field})
(td': typedef t')
(sq_t': squash (t' == fields.fd_type field))
(sq_td': squash (td' == fields.fd_typedef field))
: STT (ref td')
(pts_to r v)
(fun r' -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
= union_field0 t' r field td'
inline_for_extraction [@@noextract_to "krml"] // primitive
let union_field
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields {union_get_case v == Some field})
(#t': Type0)
(#td': typedef t')
(# [ norm_fields () ] sq_t': squash (t' == fields.fd_type field))
(# [ norm_fields () ] sq_td': squash (td' == fields.fd_typedef field))
()
: STT (ref td')
(pts_to r v)
(fun r' -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
= union_field0
t'
r
field
td'
val ununion_field
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(r: ref (union0 tn n fields))
(field: field_t fields)
(#t': Type0)
(#td': typedef t')
(#v': Ghost.erased t')
(r': ref td')
: STGhost (Ghost.erased (union_t0 tn n fields)) opened
(has_union_field r field r' `star` pts_to r' v')
(fun res -> has_union_field r field r' `star` pts_to r res)
True
(fun res ->
t' == fields.fd_type field /\
td' == fields.fd_typedef field /\
Ghost.reveal res == union_set_field tn n fields field (coerce_eq () (Ghost.reveal v'))
)
let ununion_field_and_drop
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(r: ref (union0 tn n fields))
(field: field_t fields)
(#t': Type0)
(#td': typedef t')
(#v': Ghost.erased t')
(r': ref td')
: STGhost (Ghost.erased (union_t0 tn n fields)) opened
(has_union_field r field r' `star` pts_to r' v')
(fun res -> pts_to r res)
True
(fun res ->
t' == fields.fd_type field /\
td' == fields.fd_typedef field /\
Ghost.reveal res == union_set_field tn n fields field (coerce_eq () (Ghost.reveal v'))
)
= let res = ununion_field r field r' in
drop (has_union_field _ _ _);
res
// NOTE: we DO NOT support preservation of struct prefixes
[@@noextract_to "krml"] // primitive
val union_switch_field0
(#tn: Type0)
(#tf: Type0)
(t': Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields)
(td': typedef t' {
t' == fields.fd_type field /\
td' == fields.fd_typedef field
})
: ST (ref td') // need to write the pcm carrier value, so this cannot be Ghost or Atomic
(pts_to r v)
(fun r' -> has_union_field r field r' `star` pts_to r' (uninitialized td'))
(full (union0 tn n fields) v)
(fun r' -> True)
inline_for_extraction [@@noextract_to "krml"]
let union_switch_field1
(#tn: Type0)
(#tf: Type0)
(t': Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields)
(td': typedef t')
(sq_t': squash (t' == fields.fd_type field))
(sq_td': squash (td' == fields.fd_typedef field))
: ST (ref td') // need to write the pcm carrier value, so this cannot be Ghost or Atomic
(pts_to r v)
(fun r' -> has_union_field r field r' `star` pts_to r' (uninitialized td'))
(full (union0 tn n fields) v)
(fun r' -> True)
= union_switch_field0 t' r field td' | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.C.Types.Fields.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.C.Typestring.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.ST.C.Types.Union.fsti"
} | [
{
"abbrev": true,
"full_module": "Steel.FractionalPermission",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Steel.C.Typestring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.C.Types.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.C.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.C.Types",
"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 |
r: Steel.ST.C.Types.Base.ref (Steel.ST.C.Types.Union.union0 tn n fields) ->
field: Steel.ST.C.Types.Fields.field_t fields ->
_: Prims.unit
-> Steel.ST.Effect.ST (Steel.ST.C.Types.Base.ref td') | Steel.ST.Effect.ST | [] | [] | [
"Prims.string",
"Steel.ST.C.Types.Fields.field_description_t",
"FStar.Ghost.erased",
"Steel.ST.C.Types.Union.union_t0",
"Steel.ST.C.Types.Base.ref",
"Steel.ST.C.Types.Union.union0",
"Steel.ST.C.Types.Fields.field_t",
"Steel.ST.C.Types.Base.typedef",
"Prims.squash",
"Prims.eq2",
"Steel.ST.C.Types.Fields.__proj__Mkfield_description_t__item__fd_type",
"Steel.ST.C.Types.Fields.__proj__Mkfield_description_t__item__fd_typedef",
"Prims.unit",
"Steel.ST.C.Types.Union.union_switch_field0",
"Steel.ST.C.Types.Base.pts_to",
"Steel.Effect.Common.star",
"Steel.ST.C.Types.Union.has_union_field",
"FStar.Ghost.hide",
"Steel.ST.C.Types.Base.uninitialized",
"Steel.Effect.Common.vprop",
"Steel.ST.C.Types.Base.full",
"FStar.Ghost.reveal",
"Prims.l_True"
] | [] | false | true | false | false | false | let union_switch_field
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields)
(#t': Type0)
(#td': typedef t')
(#[norm_fields ()] sq_t': squash (t' == fields.fd_type field))
(#[norm_fields ()] sq_td': squash (td' == fields.fd_typedef field))
()
: ST (ref td')
(pts_to r v)
(fun r' -> (has_union_field r field r') `star` (pts_to r' (uninitialized td')))
(full (union0 tn n fields) v)
(fun r' -> True) =
| union_switch_field0 t' r field td' | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.enum_key | val enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype | val enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype | let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } ) | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 109,
"end_line": 32,
"start_col": 0,
"start_line": 32
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | e: LowParse.Spec.Enum.enum key repr -> Prims.eqtype | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.b2t",
"LowParse.Spec.Enum.list_mem",
"LowParse.Spec.Enum.list_map",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.fst"
] | [] | false | false | false | false | false | let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype =
| (s: key{list_mem s (list_map fst e)}) | false |
Steel.ST.C.Types.Union.fsti | Steel.ST.C.Types.Union.union_switch_field1 | val union_switch_field1
(#tn #tf t': Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields)
(td': typedef t')
(sq_t': squash (t' == fields.fd_type field))
(sq_td': squash (td' == fields.fd_typedef field))
: ST (ref td')
(pts_to r v)
(fun r' -> (has_union_field r field r') `star` (pts_to r' (uninitialized td')))
(full (union0 tn n fields) v)
(fun r' -> True) | val union_switch_field1
(#tn #tf t': Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields)
(td': typedef t')
(sq_t': squash (t' == fields.fd_type field))
(sq_td': squash (td' == fields.fd_typedef field))
: ST (ref td')
(pts_to r v)
(fun r' -> (has_union_field r field r') `star` (pts_to r' (uninitialized td')))
(full (union0 tn n fields) v)
(fun r' -> True) | let union_switch_field1
(#tn: Type0)
(#tf: Type0)
(t': Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields)
(td': typedef t')
(sq_t': squash (t' == fields.fd_type field))
(sq_td': squash (td' == fields.fd_typedef field))
: ST (ref td') // need to write the pcm carrier value, so this cannot be Ghost or Atomic
(pts_to r v)
(fun r' -> has_union_field r field r' `star` pts_to r' (uninitialized td'))
(full (union0 tn n fields) v)
(fun r' -> True)
= union_switch_field0 t' r field td' | {
"file_name": "lib/steel/c/Steel.ST.C.Types.Union.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 36,
"end_line": 500,
"start_col": 0,
"start_line": 483
} | module Steel.ST.C.Types.Union
open Steel.ST.Util
include Steel.ST.C.Types.Fields
open Steel.C.Typestring
module P = Steel.FractionalPermission
[@@noextract_to "krml"] // primitive
val define_union0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot Type0
inline_for_extraction [@@noextract_to "krml"]
let define_union (n: string) (#tf: Type0) (#tn: Type0) (#[solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Tot Type0
= define_union0 tn #tf n fields
// To be extracted as: union t
[@@noextract_to "krml"] // primitive
val union_t0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot Type0
inline_for_extraction [@@noextract_to "krml"]
let union_t (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Tot Type0
= union_t0 tn #tf n fields
val union_set_field (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) (f: field_t fields) (v: fields.fd_type f) : GTot (union_t0 tn n fields)
val union_get_case
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(u: union_t0 tn n fields)
: GTot (option (field_t fields))
val union_get_field
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(u: union_t0 tn n fields)
(field: field_t fields)
: Ghost (fields.fd_type field)
(requires (union_get_case u == Some field))
(ensures (fun _ -> True))
val union_get_field_same
(tn: Type0)
(#tf: Type0)
(n: string)
(fields: field_description_t tf)
(field: field_t fields)
(v: fields.fd_type field)
: Lemma
(requires (~ (v == unknown (fields.fd_typedef field))))
(ensures (
let u = union_set_field tn n fields field v in
union_get_case u == Some field /\
union_get_field u field == v
))
[SMTPatOr [
[SMTPat (union_get_case (union_set_field tn n fields field v))];
[SMTPat (union_get_field (union_set_field tn n fields field v) field)];
]]
val union_set_field_same
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(s: union_t0 tn n fields)
(field: field_t fields)
: Lemma
(requires (union_get_case s == Some field))
(ensures (
union_set_field tn n fields field (union_get_field s field) == s
))
[SMTPat (union_set_field tn n fields (union_get_field s field))]
[@@noextract_to "krml"] // proof-only
val union0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot (typedef (union_t0 tn n fields))
inline_for_extraction
[@@noextract_to "krml"; norm_field_attr] // proof-only
let union (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Tot (typedef (union_t0 tn n fields))
= union0 tn #tf n fields
val union_get_case_unknown
(tn: Type0)
(#tf: Type0)
(n: string)
(fields: field_description_t tf)
: Lemma
(union_get_case (unknown (union0 tn n fields)) == None)
[SMTPat (unknown (union0 tn n fields))]
val union_set_field_unknown
(tn: Type0)
(#tf: Type0)
(n: string)
(fields: field_description_t tf)
(field: field_t fields)
: Lemma
(union_set_field tn n fields field (unknown (fields.fd_typedef field)) == unknown (union0 tn n fields))
[SMTPat (union_set_field tn n fields field (unknown (fields.fd_typedef field)))]
val union_get_case_uninitialized
(tn: Type0)
(#tf: Type0)
(n: string)
(fields: field_description_t tf)
: Lemma
(union_get_case (uninitialized (union0 tn n fields)) == None)
[SMTPat (uninitialized (union0 tn n fields))]
val mk_fraction_union_get_case
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(s: union_t0 tn n fields)
(p: P.perm)
: Lemma
(requires (fractionable (union0 tn n fields) s))
(ensures (
union_get_case (mk_fraction (union0 tn n fields) s p) == union_get_case s
))
[SMTPat (union_get_case (mk_fraction (union0 tn n fields) s p))]
val fractionable_union_get_field
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(s: union_t0 tn n fields)
(field: field_t fields)
: Lemma
(requires (union_get_case s == Some field))
(ensures (
fractionable (union0 tn n fields) s <==> fractionable (fields.fd_typedef field) (union_get_field s field)
))
[SMTPat (fractionable (union0 tn n fields) s); SMTPat (union_get_field s field)]
val mk_fraction_union_get_field
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(s: union_t0 tn n fields)
(p: P.perm)
(field: field_t fields)
: Lemma
(requires (fractionable (union0 tn n fields) s /\ union_get_case s == Some field))
(ensures (union_get_field (mk_fraction (union0 tn n fields) s p) field == mk_fraction (fields.fd_typedef field) (union_get_field s field) p))
[SMTPat (union_get_field (mk_fraction (union0 tn n fields) s p) field)]
val mk_fraction_union_set_field
(tn: Type0)
(#tf: Type0)
(n: string)
(fields: field_description_t tf)
(field: field_t fields)
(v: fields.fd_type field)
(p: P.perm)
: Lemma
(requires (fractionable (fields.fd_typedef field) v))
(ensures (
fractionable (union0 tn n fields) (union_set_field tn n fields field v) /\
mk_fraction (union0 tn n fields) (union_set_field tn n fields field v) p == union_set_field tn n fields field (mk_fraction (fields.fd_typedef field) v p)
))
val full_union
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(s: union_t0 tn n fields)
(field: field_t fields)
: Lemma
(requires (union_get_case s == Some field))
(ensures (
full (union0 tn n fields) s <==> full (fields.fd_typedef field) (union_get_field s field)
))
[SMTPat (full (union0 tn n fields) s); SMTPat (union_get_field s field)]
let full_union_set_field_intro
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(field: field_t fields)
(v: fields.fd_type field)
: Lemma
(requires (full (fields.fd_typedef field) v))
(ensures (
full (union0 tn n fields) (union_set_field tn n fields field v)
))
= full_union (union_set_field tn n fields field v) field
let full_union_set_field_elim
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(field: field_t fields)
(v: fields.fd_type field)
: Lemma
(requires (
full (union0 tn n fields) (union_set_field tn n fields field v)
))
(ensures (
full (fields.fd_typedef field) v
))
= full_union (union_set_field tn n fields field v) field
let full_union_set_field
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(field: field_t fields)
(v: fields.fd_type field)
: Lemma
(requires True)
(ensures (
full (union0 tn n fields) (union_set_field tn n fields field v) <==> full (fields.fd_typedef field) v
))
[SMTPat (full (union0 tn n fields) (union_set_field tn n fields field v))]
= Classical.move_requires (full_union_set_field_intro #tn #tf #n #fields field) v;
Classical.move_requires (full_union_set_field_elim #tn #tf #n #fields field) v
val has_union_field
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(r: ref (union0 tn n fields))
(field: field_t fields)
(#t': Type0)
(#td': typedef t')
(r': ref td')
: Tot vprop
val has_union_field_prop
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(r: ref (union0 tn n fields))
(field: field_t fields)
(#t': Type0)
(#td': typedef t')
(r': ref td')
: STGhost unit opened
(has_union_field r field r')
(fun _ -> has_union_field r field r')
True
(fun _ ->
t' == fields.fd_type field /\
td' == fields.fd_typedef field
)
val has_union_field_dup
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: nonempty_field_description_t tf)
(r: ref (union0 tn n fields))
(field: field_t fields)
(#t': Type0)
(#td': typedef t')
(r': ref td')
: STGhostT unit opened
(has_union_field r field r')
(fun _ -> has_union_field r field r' `star` has_union_field r field r')
val has_union_field_inj
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: nonempty_field_description_t tf)
(r: ref (union0 tn n fields))
(field: field_t fields)
(#t1: Type0)
(#td1: typedef t1)
(r1: ref td1)
(#t2: Type0)
(#td2: typedef t2)
(r2: ref td2)
: STGhostT (squash (t1 == t2 /\ td1 == td2)) opened
(has_union_field r field r1 `star` has_union_field r field r2)
(fun _ -> has_union_field r field r1 `star` has_union_field r field r2 `star` ref_equiv r1 (coerce_eq () r2))
val has_union_field_equiv_from
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: nonempty_field_description_t tf)
(r1 r2: ref (union0 tn n fields))
(field: field_t fields)
(#t': Type0)
(#td': typedef t')
(r': ref td')
: STGhostT unit opened
(has_union_field r1 field r' `star` ref_equiv r1 r2)
(fun _ -> has_union_field r2 field r' `star` ref_equiv r1 r2)
val has_union_field_equiv_to
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: nonempty_field_description_t tf)
(r: ref (union0 tn n fields))
(field: field_t fields)
(#t': Type0)
(#td': typedef t')
(r1 r2: ref td')
: STGhostT unit opened
(has_union_field r field r1 `star` ref_equiv r1 r2)
(fun _ -> has_union_field r field r2 `star` ref_equiv r1 r2)
val ghost_union_field_focus
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields {union_get_case v == Some field})
(#t': Type0)
(#td': typedef t')
(r': ref td')
: STGhostT (squash (
t' == fields.fd_type field /\
td' == fields.fd_typedef field
)) opened
(has_union_field r field r' `star` pts_to r v)
(fun _ -> has_union_field r field r' `star` pts_to r' (Ghost.hide (coerce_eq () (union_get_field v field))))
val ghost_union_field
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields {union_get_case v == Some field})
: STGhostT (Ghost.erased (ref (fields.fd_typedef field))) opened
(pts_to r v)
(fun r' -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
[@@noextract_to "krml"] // primitive
val union_field0
(#tn: Type0)
(#tf: Type0)
(t': Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields {union_get_case v == Some field})
(td': typedef t' {
t' == fields.fd_type field /\
td' == fields.fd_typedef field
})
: STT (ref td')
(pts_to r v)
(fun r' -> has_union_field r field r' `star` pts_to r' (Ghost.hide (coerce_eq () (union_get_field v field))))
inline_for_extraction [@@noextract_to "krml"]
let union_field1
(#tn: Type0)
(#tf: Type0)
(t': Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields {union_get_case v == Some field})
(td': typedef t')
(sq_t': squash (t' == fields.fd_type field))
(sq_td': squash (td' == fields.fd_typedef field))
: STT (ref td')
(pts_to r v)
(fun r' -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
= union_field0 t' r field td'
inline_for_extraction [@@noextract_to "krml"] // primitive
let union_field
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields {union_get_case v == Some field})
(#t': Type0)
(#td': typedef t')
(# [ norm_fields () ] sq_t': squash (t' == fields.fd_type field))
(# [ norm_fields () ] sq_td': squash (td' == fields.fd_typedef field))
()
: STT (ref td')
(pts_to r v)
(fun r' -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
= union_field0
t'
r
field
td'
val ununion_field
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(r: ref (union0 tn n fields))
(field: field_t fields)
(#t': Type0)
(#td': typedef t')
(#v': Ghost.erased t')
(r': ref td')
: STGhost (Ghost.erased (union_t0 tn n fields)) opened
(has_union_field r field r' `star` pts_to r' v')
(fun res -> has_union_field r field r' `star` pts_to r res)
True
(fun res ->
t' == fields.fd_type field /\
td' == fields.fd_typedef field /\
Ghost.reveal res == union_set_field tn n fields field (coerce_eq () (Ghost.reveal v'))
)
let ununion_field_and_drop
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(r: ref (union0 tn n fields))
(field: field_t fields)
(#t': Type0)
(#td': typedef t')
(#v': Ghost.erased t')
(r': ref td')
: STGhost (Ghost.erased (union_t0 tn n fields)) opened
(has_union_field r field r' `star` pts_to r' v')
(fun res -> pts_to r res)
True
(fun res ->
t' == fields.fd_type field /\
td' == fields.fd_typedef field /\
Ghost.reveal res == union_set_field tn n fields field (coerce_eq () (Ghost.reveal v'))
)
= let res = ununion_field r field r' in
drop (has_union_field _ _ _);
res
// NOTE: we DO NOT support preservation of struct prefixes
[@@noextract_to "krml"] // primitive
val union_switch_field0
(#tn: Type0)
(#tf: Type0)
(t': Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields)
(td': typedef t' {
t' == fields.fd_type field /\
td' == fields.fd_typedef field
})
: ST (ref td') // need to write the pcm carrier value, so this cannot be Ghost or Atomic
(pts_to r v)
(fun r' -> has_union_field r field r' `star` pts_to r' (uninitialized td'))
(full (union0 tn n fields) v)
(fun r' -> True) | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.C.Types.Fields.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.C.Typestring.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.ST.C.Types.Union.fsti"
} | [
{
"abbrev": true,
"full_module": "Steel.FractionalPermission",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Steel.C.Typestring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.C.Types.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.C.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.C.Types",
"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 |
t': Type0 ->
r: Steel.ST.C.Types.Base.ref (Steel.ST.C.Types.Union.union0 tn n fields) ->
field: Steel.ST.C.Types.Fields.field_t fields ->
td': Steel.ST.C.Types.Base.typedef t' ->
sq_t': Prims.squash (t' == Mkfield_description_t?.fd_type fields field) ->
sq_td': Prims.squash (td' == Mkfield_description_t?.fd_typedef fields field)
-> Steel.ST.Effect.ST (Steel.ST.C.Types.Base.ref td') | Steel.ST.Effect.ST | [] | [] | [
"Prims.string",
"Steel.ST.C.Types.Fields.field_description_t",
"FStar.Ghost.erased",
"Steel.ST.C.Types.Union.union_t0",
"Steel.ST.C.Types.Base.ref",
"Steel.ST.C.Types.Union.union0",
"Steel.ST.C.Types.Fields.field_t",
"Steel.ST.C.Types.Base.typedef",
"Prims.squash",
"Prims.eq2",
"Steel.ST.C.Types.Fields.__proj__Mkfield_description_t__item__fd_type",
"Steel.ST.C.Types.Fields.__proj__Mkfield_description_t__item__fd_typedef",
"Steel.ST.C.Types.Union.union_switch_field0",
"Steel.ST.C.Types.Base.pts_to",
"Steel.Effect.Common.star",
"Steel.ST.C.Types.Union.has_union_field",
"FStar.Ghost.hide",
"Steel.ST.C.Types.Base.uninitialized",
"Steel.Effect.Common.vprop",
"Steel.ST.C.Types.Base.full",
"FStar.Ghost.reveal",
"Prims.l_True"
] | [] | false | true | false | false | false | let union_switch_field1
(#tn #tf t': Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields)
(td': typedef t')
(sq_t': squash (t' == fields.fd_type field))
(sq_td': squash (td' == fields.fd_typedef field))
: ST (ref td')
(pts_to r v)
(fun r' -> (has_union_field r field r') `star` (pts_to r' (uninitialized td')))
(full (union0 tn n fields) v)
(fun r' -> True) =
| union_switch_field0 t' r field td' | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.map_flip_flip | val map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma (list_map flip (list_map flip l) == l) | val map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma (list_map flip (list_map flip l) == l) | let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 29,
"end_line": 49,
"start_col": 0,
"start_line": 45
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | l: Prims.list (a * b)
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Enum.list_map LowParse.Spec.Enum.flip
(LowParse.Spec.Enum.list_map LowParse.Spec.Enum.flip l) ==
l) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.map_flip_flip",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"LowParse.Spec.Enum.list_map",
"LowParse.Spec.Enum.flip",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma (list_map flip (list_map flip l) == l) =
| match l with
| [] -> ()
| _ :: q -> map_flip_flip q | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.map_snd_flip | val map_snd_flip (#a #b: Type) (l: list (a * b))
: Lemma (list_map snd (list_map flip l) == list_map fst l) | val map_snd_flip (#a #b: Type) (l: list (a * b))
: Lemma (list_map snd (list_map flip l) == list_map fst l) | let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 28,
"end_line": 61,
"start_col": 0,
"start_line": 57
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | l: Prims.list (a * b)
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Enum.list_map FStar.Pervasives.Native.snd
(LowParse.Spec.Enum.list_map LowParse.Spec.Enum.flip l) ==
LowParse.Spec.Enum.list_map FStar.Pervasives.Native.fst l) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.map_snd_flip",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.l_or",
"FStar.List.Tot.Base.map",
"FStar.Pervasives.Native.fst",
"FStar.Pervasives.Native.snd",
"LowParse.Spec.Enum.list_map",
"LowParse.Spec.Enum.flip",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec map_snd_flip (#a #b: Type) (l: list (a * b))
: Lemma (list_map snd (list_map flip l) == list_map fst l) =
| match l with
| [] -> ()
| _ :: q -> map_snd_flip q | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.assoc_mem_snd | val assoc_mem_snd (#a #b: eqtype) (l: list (a * b)) (x: a) (y: b)
: Lemma (requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l) | val assoc_mem_snd (#a #b: eqtype) (l: list (a * b)) (x: a) (y: b)
: Lemma (requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l) | let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 27,
"end_line": 75,
"start_col": 0,
"start_line": 63
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | l: Prims.list (a * b) -> x: a -> y: b
-> FStar.Pervasives.Lemma
(requires FStar.List.Tot.Base.assoc x l == FStar.Pervasives.Native.Some y)
(ensures
LowParse.Spec.Enum.list_mem y (LowParse.Spec.Enum.list_map FStar.Pervasives.Native.snd l) ==
true)
(decreases l) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"Prims.eqtype",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.op_Equality",
"Prims.bool",
"LowParse.Spec.Enum.assoc_mem_snd",
"Prims.unit",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.List.Tot.Base.assoc",
"FStar.Pervasives.Native.Some",
"Prims.squash",
"LowParse.Spec.Enum.list_mem",
"LowParse.Spec.Enum.list_map",
"FStar.Pervasives.Native.snd",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec assoc_mem_snd (#a #b: eqtype) (l: list (a * b)) (x: a) (y: b)
: Lemma (requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l) =
| let (x', y') :: l' = l in
if x' = x then () else assoc_mem_snd l' x y | false |
Steel.ST.C.Types.Union.fsti | Steel.ST.C.Types.Union.union_field | val union_field:
#tn: Type0 ->
#tf: Type0 ->
#n: string ->
#fields: field_description_t tf ->
#v: Ghost.erased (union_t0 tn n fields) ->
r: ref (union0 tn n fields) ->
field: field_t fields {union_get_case v == Some field} ->
#t': Type0 ->
#td': typedef t' ->
(#[norm_fields ()] sq_t': squash (t' == fields.fd_type field)) ->
(#[norm_fields ()] sq_td': squash (td' == fields.fd_typedef field)) ->
Prims.unit
-> STT (ref td')
(pts_to r v)
(fun r' -> (has_union_field r field r') `star` (pts_to r' (union_get_field v field))) | val union_field:
#tn: Type0 ->
#tf: Type0 ->
#n: string ->
#fields: field_description_t tf ->
#v: Ghost.erased (union_t0 tn n fields) ->
r: ref (union0 tn n fields) ->
field: field_t fields {union_get_case v == Some field} ->
#t': Type0 ->
#td': typedef t' ->
(#[norm_fields ()] sq_t': squash (t' == fields.fd_type field)) ->
(#[norm_fields ()] sq_td': squash (td' == fields.fd_typedef field)) ->
Prims.unit
-> STT (ref td')
(pts_to r v)
(fun r' -> (has_union_field r field r') `star` (pts_to r' (union_get_field v field))) | let union_field
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields {union_get_case v == Some field})
(#t': Type0)
(#td': typedef t')
(# [ norm_fields () ] sq_t': squash (t' == fields.fd_type field))
(# [ norm_fields () ] sq_td': squash (td' == fields.fd_typedef field))
()
: STT (ref td')
(pts_to r v)
(fun r' -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
= union_field0
t'
r
field
td' | {
"file_name": "lib/steel/c/Steel.ST.C.Types.Union.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 7,
"end_line": 411,
"start_col": 0,
"start_line": 391
} | module Steel.ST.C.Types.Union
open Steel.ST.Util
include Steel.ST.C.Types.Fields
open Steel.C.Typestring
module P = Steel.FractionalPermission
[@@noextract_to "krml"] // primitive
val define_union0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot Type0
inline_for_extraction [@@noextract_to "krml"]
let define_union (n: string) (#tf: Type0) (#tn: Type0) (#[solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Tot Type0
= define_union0 tn #tf n fields
// To be extracted as: union t
[@@noextract_to "krml"] // primitive
val union_t0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot Type0
inline_for_extraction [@@noextract_to "krml"]
let union_t (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Tot Type0
= union_t0 tn #tf n fields
val union_set_field (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) (f: field_t fields) (v: fields.fd_type f) : GTot (union_t0 tn n fields)
val union_get_case
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(u: union_t0 tn n fields)
: GTot (option (field_t fields))
val union_get_field
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(u: union_t0 tn n fields)
(field: field_t fields)
: Ghost (fields.fd_type field)
(requires (union_get_case u == Some field))
(ensures (fun _ -> True))
val union_get_field_same
(tn: Type0)
(#tf: Type0)
(n: string)
(fields: field_description_t tf)
(field: field_t fields)
(v: fields.fd_type field)
: Lemma
(requires (~ (v == unknown (fields.fd_typedef field))))
(ensures (
let u = union_set_field tn n fields field v in
union_get_case u == Some field /\
union_get_field u field == v
))
[SMTPatOr [
[SMTPat (union_get_case (union_set_field tn n fields field v))];
[SMTPat (union_get_field (union_set_field tn n fields field v) field)];
]]
val union_set_field_same
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(s: union_t0 tn n fields)
(field: field_t fields)
: Lemma
(requires (union_get_case s == Some field))
(ensures (
union_set_field tn n fields field (union_get_field s field) == s
))
[SMTPat (union_set_field tn n fields (union_get_field s field))]
[@@noextract_to "krml"] // proof-only
val union0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot (typedef (union_t0 tn n fields))
inline_for_extraction
[@@noextract_to "krml"; norm_field_attr] // proof-only
let union (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Tot (typedef (union_t0 tn n fields))
= union0 tn #tf n fields
val union_get_case_unknown
(tn: Type0)
(#tf: Type0)
(n: string)
(fields: field_description_t tf)
: Lemma
(union_get_case (unknown (union0 tn n fields)) == None)
[SMTPat (unknown (union0 tn n fields))]
val union_set_field_unknown
(tn: Type0)
(#tf: Type0)
(n: string)
(fields: field_description_t tf)
(field: field_t fields)
: Lemma
(union_set_field tn n fields field (unknown (fields.fd_typedef field)) == unknown (union0 tn n fields))
[SMTPat (union_set_field tn n fields field (unknown (fields.fd_typedef field)))]
val union_get_case_uninitialized
(tn: Type0)
(#tf: Type0)
(n: string)
(fields: field_description_t tf)
: Lemma
(union_get_case (uninitialized (union0 tn n fields)) == None)
[SMTPat (uninitialized (union0 tn n fields))]
val mk_fraction_union_get_case
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(s: union_t0 tn n fields)
(p: P.perm)
: Lemma
(requires (fractionable (union0 tn n fields) s))
(ensures (
union_get_case (mk_fraction (union0 tn n fields) s p) == union_get_case s
))
[SMTPat (union_get_case (mk_fraction (union0 tn n fields) s p))]
val fractionable_union_get_field
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(s: union_t0 tn n fields)
(field: field_t fields)
: Lemma
(requires (union_get_case s == Some field))
(ensures (
fractionable (union0 tn n fields) s <==> fractionable (fields.fd_typedef field) (union_get_field s field)
))
[SMTPat (fractionable (union0 tn n fields) s); SMTPat (union_get_field s field)]
val mk_fraction_union_get_field
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(s: union_t0 tn n fields)
(p: P.perm)
(field: field_t fields)
: Lemma
(requires (fractionable (union0 tn n fields) s /\ union_get_case s == Some field))
(ensures (union_get_field (mk_fraction (union0 tn n fields) s p) field == mk_fraction (fields.fd_typedef field) (union_get_field s field) p))
[SMTPat (union_get_field (mk_fraction (union0 tn n fields) s p) field)]
val mk_fraction_union_set_field
(tn: Type0)
(#tf: Type0)
(n: string)
(fields: field_description_t tf)
(field: field_t fields)
(v: fields.fd_type field)
(p: P.perm)
: Lemma
(requires (fractionable (fields.fd_typedef field) v))
(ensures (
fractionable (union0 tn n fields) (union_set_field tn n fields field v) /\
mk_fraction (union0 tn n fields) (union_set_field tn n fields field v) p == union_set_field tn n fields field (mk_fraction (fields.fd_typedef field) v p)
))
val full_union
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(s: union_t0 tn n fields)
(field: field_t fields)
: Lemma
(requires (union_get_case s == Some field))
(ensures (
full (union0 tn n fields) s <==> full (fields.fd_typedef field) (union_get_field s field)
))
[SMTPat (full (union0 tn n fields) s); SMTPat (union_get_field s field)]
let full_union_set_field_intro
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(field: field_t fields)
(v: fields.fd_type field)
: Lemma
(requires (full (fields.fd_typedef field) v))
(ensures (
full (union0 tn n fields) (union_set_field tn n fields field v)
))
= full_union (union_set_field tn n fields field v) field
let full_union_set_field_elim
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(field: field_t fields)
(v: fields.fd_type field)
: Lemma
(requires (
full (union0 tn n fields) (union_set_field tn n fields field v)
))
(ensures (
full (fields.fd_typedef field) v
))
= full_union (union_set_field tn n fields field v) field
let full_union_set_field
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(field: field_t fields)
(v: fields.fd_type field)
: Lemma
(requires True)
(ensures (
full (union0 tn n fields) (union_set_field tn n fields field v) <==> full (fields.fd_typedef field) v
))
[SMTPat (full (union0 tn n fields) (union_set_field tn n fields field v))]
= Classical.move_requires (full_union_set_field_intro #tn #tf #n #fields field) v;
Classical.move_requires (full_union_set_field_elim #tn #tf #n #fields field) v
val has_union_field
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(r: ref (union0 tn n fields))
(field: field_t fields)
(#t': Type0)
(#td': typedef t')
(r': ref td')
: Tot vprop
val has_union_field_prop
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(r: ref (union0 tn n fields))
(field: field_t fields)
(#t': Type0)
(#td': typedef t')
(r': ref td')
: STGhost unit opened
(has_union_field r field r')
(fun _ -> has_union_field r field r')
True
(fun _ ->
t' == fields.fd_type field /\
td' == fields.fd_typedef field
)
val has_union_field_dup
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: nonempty_field_description_t tf)
(r: ref (union0 tn n fields))
(field: field_t fields)
(#t': Type0)
(#td': typedef t')
(r': ref td')
: STGhostT unit opened
(has_union_field r field r')
(fun _ -> has_union_field r field r' `star` has_union_field r field r')
val has_union_field_inj
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: nonempty_field_description_t tf)
(r: ref (union0 tn n fields))
(field: field_t fields)
(#t1: Type0)
(#td1: typedef t1)
(r1: ref td1)
(#t2: Type0)
(#td2: typedef t2)
(r2: ref td2)
: STGhostT (squash (t1 == t2 /\ td1 == td2)) opened
(has_union_field r field r1 `star` has_union_field r field r2)
(fun _ -> has_union_field r field r1 `star` has_union_field r field r2 `star` ref_equiv r1 (coerce_eq () r2))
val has_union_field_equiv_from
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: nonempty_field_description_t tf)
(r1 r2: ref (union0 tn n fields))
(field: field_t fields)
(#t': Type0)
(#td': typedef t')
(r': ref td')
: STGhostT unit opened
(has_union_field r1 field r' `star` ref_equiv r1 r2)
(fun _ -> has_union_field r2 field r' `star` ref_equiv r1 r2)
val has_union_field_equiv_to
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: nonempty_field_description_t tf)
(r: ref (union0 tn n fields))
(field: field_t fields)
(#t': Type0)
(#td': typedef t')
(r1 r2: ref td')
: STGhostT unit opened
(has_union_field r field r1 `star` ref_equiv r1 r2)
(fun _ -> has_union_field r field r2 `star` ref_equiv r1 r2)
val ghost_union_field_focus
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields {union_get_case v == Some field})
(#t': Type0)
(#td': typedef t')
(r': ref td')
: STGhostT (squash (
t' == fields.fd_type field /\
td' == fields.fd_typedef field
)) opened
(has_union_field r field r' `star` pts_to r v)
(fun _ -> has_union_field r field r' `star` pts_to r' (Ghost.hide (coerce_eq () (union_get_field v field))))
val ghost_union_field
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields {union_get_case v == Some field})
: STGhostT (Ghost.erased (ref (fields.fd_typedef field))) opened
(pts_to r v)
(fun r' -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
[@@noextract_to "krml"] // primitive
val union_field0
(#tn: Type0)
(#tf: Type0)
(t': Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields {union_get_case v == Some field})
(td': typedef t' {
t' == fields.fd_type field /\
td' == fields.fd_typedef field
})
: STT (ref td')
(pts_to r v)
(fun r' -> has_union_field r field r' `star` pts_to r' (Ghost.hide (coerce_eq () (union_get_field v field))))
inline_for_extraction [@@noextract_to "krml"]
let union_field1
(#tn: Type0)
(#tf: Type0)
(t': Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields {union_get_case v == Some field})
(td': typedef t')
(sq_t': squash (t' == fields.fd_type field))
(sq_td': squash (td' == fields.fd_typedef field))
: STT (ref td')
(pts_to r v)
(fun r' -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
= union_field0 t' r field td' | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.C.Types.Fields.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.C.Typestring.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.ST.C.Types.Union.fsti"
} | [
{
"abbrev": true,
"full_module": "Steel.FractionalPermission",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Steel.C.Typestring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.C.Types.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.C.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.C.Types",
"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 |
r: Steel.ST.C.Types.Base.ref (Steel.ST.C.Types.Union.union0 tn n fields) ->
field:
Steel.ST.C.Types.Fields.field_t fields
{ Steel.ST.C.Types.Union.union_get_case (FStar.Ghost.reveal v) ==
FStar.Pervasives.Native.Some field } ->
_: Prims.unit
-> Steel.ST.Effect.STT (Steel.ST.C.Types.Base.ref td') | Steel.ST.Effect.STT | [] | [] | [
"Prims.string",
"Steel.ST.C.Types.Fields.field_description_t",
"FStar.Ghost.erased",
"Steel.ST.C.Types.Union.union_t0",
"Steel.ST.C.Types.Base.ref",
"Steel.ST.C.Types.Union.union0",
"Steel.ST.C.Types.Fields.field_t",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"Steel.ST.C.Types.Union.union_get_case",
"FStar.Ghost.reveal",
"FStar.Pervasives.Native.Some",
"Steel.ST.C.Types.Base.typedef",
"Prims.squash",
"Steel.ST.C.Types.Fields.__proj__Mkfield_description_t__item__fd_type",
"Steel.ST.C.Types.Fields.__proj__Mkfield_description_t__item__fd_typedef",
"Prims.unit",
"Steel.ST.C.Types.Union.union_field0",
"Steel.ST.C.Types.Base.pts_to",
"Steel.Effect.Common.star",
"Steel.ST.C.Types.Union.has_union_field",
"FStar.Ghost.hide",
"Steel.ST.C.Types.Union.union_get_field",
"Steel.Effect.Common.vprop"
] | [] | false | true | false | false | false | let union_field
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields {union_get_case v == Some field})
(#t': Type0)
(#td': typedef t')
(#[norm_fields ()] sq_t': squash (t' == fields.fd_type field))
(#[norm_fields ()] sq_td': squash (td' == fields.fd_typedef field))
()
: STT (ref td')
(pts_to r v)
(fun r' -> (has_union_field r field r') `star` (pts_to r' (union_get_field v field))) =
| union_field0 t' r field td' | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.enum_key_of_repr | val enum_key_of_repr (#key #repr: eqtype) (e: enum key repr) (r: enum_repr e)
: Pure (enum_key e) (requires True) (ensures (fun y -> L.assoc y e == Some r)) | val enum_key_of_repr (#key #repr: eqtype) (e: enum key repr) (r: enum_repr e)
: Pure (enum_key e) (requires True) (ensures (fun y -> L.assoc y e == Some r)) | let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e) | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 19,
"end_line": 139,
"start_col": 0,
"start_line": 126
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | e: LowParse.Spec.Enum.enum key repr -> r: LowParse.Spec.Enum.enum_repr e
-> Prims.Pure (LowParse.Spec.Enum.enum_key e) | Prims.Pure | [] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.enum_repr",
"LowParse.Spec.Enum.enum_key",
"Prims.unit",
"FStar.List.Tot.Properties.assoc_mem",
"LowParse.Spec.Enum.assoc_flip_elim",
"FStar.Pervasives.Native.__proj__Some__item__v",
"FStar.List.Tot.Base.assoc",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.eq2",
"FStar.List.Tot.Base.map",
"LowParse.Spec.Enum.flip",
"LowParse.Spec.Enum.list_map",
"LowParse.Spec.Enum.map_fst_flip",
"Prims.l_True",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.Some"
] | [] | false | false | false | false | false | let enum_key_of_repr (#key #repr: eqtype) (e: enum key repr) (r: enum_repr e)
: Pure (enum_key e) (requires True) (ensures (fun y -> L.assoc y e == Some r)) =
| map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e) | false |
Steel.ST.C.Types.Union.fsti | Steel.ST.C.Types.Union.union_field1 | val union_field1
(#tn #tf t': Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields {union_get_case v == Some field})
(td': typedef t')
(sq_t': squash (t' == fields.fd_type field))
(sq_td': squash (td' == fields.fd_typedef field))
: STT (ref td')
(pts_to r v)
(fun r' -> (has_union_field r field r') `star` (pts_to r' (union_get_field v field))) | val union_field1
(#tn #tf t': Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields {union_get_case v == Some field})
(td': typedef t')
(sq_t': squash (t' == fields.fd_type field))
(sq_td': squash (td' == fields.fd_typedef field))
: STT (ref td')
(pts_to r v)
(fun r' -> (has_union_field r field r') `star` (pts_to r' (union_get_field v field))) | let union_field1
(#tn: Type0)
(#tf: Type0)
(t': Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields {union_get_case v == Some field})
(td': typedef t')
(sq_t': squash (t' == fields.fd_type field))
(sq_td': squash (td' == fields.fd_typedef field))
: STT (ref td')
(pts_to r v)
(fun r' -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
= union_field0 t' r field td' | {
"file_name": "lib/steel/c/Steel.ST.C.Types.Union.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 29,
"end_line": 388,
"start_col": 0,
"start_line": 373
} | module Steel.ST.C.Types.Union
open Steel.ST.Util
include Steel.ST.C.Types.Fields
open Steel.C.Typestring
module P = Steel.FractionalPermission
[@@noextract_to "krml"] // primitive
val define_union0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot Type0
inline_for_extraction [@@noextract_to "krml"]
let define_union (n: string) (#tf: Type0) (#tn: Type0) (#[solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Tot Type0
= define_union0 tn #tf n fields
// To be extracted as: union t
[@@noextract_to "krml"] // primitive
val union_t0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot Type0
inline_for_extraction [@@noextract_to "krml"]
let union_t (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Tot Type0
= union_t0 tn #tf n fields
val union_set_field (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) (f: field_t fields) (v: fields.fd_type f) : GTot (union_t0 tn n fields)
val union_get_case
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(u: union_t0 tn n fields)
: GTot (option (field_t fields))
val union_get_field
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(u: union_t0 tn n fields)
(field: field_t fields)
: Ghost (fields.fd_type field)
(requires (union_get_case u == Some field))
(ensures (fun _ -> True))
val union_get_field_same
(tn: Type0)
(#tf: Type0)
(n: string)
(fields: field_description_t tf)
(field: field_t fields)
(v: fields.fd_type field)
: Lemma
(requires (~ (v == unknown (fields.fd_typedef field))))
(ensures (
let u = union_set_field tn n fields field v in
union_get_case u == Some field /\
union_get_field u field == v
))
[SMTPatOr [
[SMTPat (union_get_case (union_set_field tn n fields field v))];
[SMTPat (union_get_field (union_set_field tn n fields field v) field)];
]]
val union_set_field_same
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(s: union_t0 tn n fields)
(field: field_t fields)
: Lemma
(requires (union_get_case s == Some field))
(ensures (
union_set_field tn n fields field (union_get_field s field) == s
))
[SMTPat (union_set_field tn n fields (union_get_field s field))]
[@@noextract_to "krml"] // proof-only
val union0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot (typedef (union_t0 tn n fields))
inline_for_extraction
[@@noextract_to "krml"; norm_field_attr] // proof-only
let union (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Tot (typedef (union_t0 tn n fields))
= union0 tn #tf n fields
val union_get_case_unknown
(tn: Type0)
(#tf: Type0)
(n: string)
(fields: field_description_t tf)
: Lemma
(union_get_case (unknown (union0 tn n fields)) == None)
[SMTPat (unknown (union0 tn n fields))]
val union_set_field_unknown
(tn: Type0)
(#tf: Type0)
(n: string)
(fields: field_description_t tf)
(field: field_t fields)
: Lemma
(union_set_field tn n fields field (unknown (fields.fd_typedef field)) == unknown (union0 tn n fields))
[SMTPat (union_set_field tn n fields field (unknown (fields.fd_typedef field)))]
val union_get_case_uninitialized
(tn: Type0)
(#tf: Type0)
(n: string)
(fields: field_description_t tf)
: Lemma
(union_get_case (uninitialized (union0 tn n fields)) == None)
[SMTPat (uninitialized (union0 tn n fields))]
val mk_fraction_union_get_case
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(s: union_t0 tn n fields)
(p: P.perm)
: Lemma
(requires (fractionable (union0 tn n fields) s))
(ensures (
union_get_case (mk_fraction (union0 tn n fields) s p) == union_get_case s
))
[SMTPat (union_get_case (mk_fraction (union0 tn n fields) s p))]
val fractionable_union_get_field
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(s: union_t0 tn n fields)
(field: field_t fields)
: Lemma
(requires (union_get_case s == Some field))
(ensures (
fractionable (union0 tn n fields) s <==> fractionable (fields.fd_typedef field) (union_get_field s field)
))
[SMTPat (fractionable (union0 tn n fields) s); SMTPat (union_get_field s field)]
val mk_fraction_union_get_field
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(s: union_t0 tn n fields)
(p: P.perm)
(field: field_t fields)
: Lemma
(requires (fractionable (union0 tn n fields) s /\ union_get_case s == Some field))
(ensures (union_get_field (mk_fraction (union0 tn n fields) s p) field == mk_fraction (fields.fd_typedef field) (union_get_field s field) p))
[SMTPat (union_get_field (mk_fraction (union0 tn n fields) s p) field)]
val mk_fraction_union_set_field
(tn: Type0)
(#tf: Type0)
(n: string)
(fields: field_description_t tf)
(field: field_t fields)
(v: fields.fd_type field)
(p: P.perm)
: Lemma
(requires (fractionable (fields.fd_typedef field) v))
(ensures (
fractionable (union0 tn n fields) (union_set_field tn n fields field v) /\
mk_fraction (union0 tn n fields) (union_set_field tn n fields field v) p == union_set_field tn n fields field (mk_fraction (fields.fd_typedef field) v p)
))
val full_union
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(s: union_t0 tn n fields)
(field: field_t fields)
: Lemma
(requires (union_get_case s == Some field))
(ensures (
full (union0 tn n fields) s <==> full (fields.fd_typedef field) (union_get_field s field)
))
[SMTPat (full (union0 tn n fields) s); SMTPat (union_get_field s field)]
let full_union_set_field_intro
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(field: field_t fields)
(v: fields.fd_type field)
: Lemma
(requires (full (fields.fd_typedef field) v))
(ensures (
full (union0 tn n fields) (union_set_field tn n fields field v)
))
= full_union (union_set_field tn n fields field v) field
let full_union_set_field_elim
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(field: field_t fields)
(v: fields.fd_type field)
: Lemma
(requires (
full (union0 tn n fields) (union_set_field tn n fields field v)
))
(ensures (
full (fields.fd_typedef field) v
))
= full_union (union_set_field tn n fields field v) field
let full_union_set_field
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(field: field_t fields)
(v: fields.fd_type field)
: Lemma
(requires True)
(ensures (
full (union0 tn n fields) (union_set_field tn n fields field v) <==> full (fields.fd_typedef field) v
))
[SMTPat (full (union0 tn n fields) (union_set_field tn n fields field v))]
= Classical.move_requires (full_union_set_field_intro #tn #tf #n #fields field) v;
Classical.move_requires (full_union_set_field_elim #tn #tf #n #fields field) v
val has_union_field
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(r: ref (union0 tn n fields))
(field: field_t fields)
(#t': Type0)
(#td': typedef t')
(r': ref td')
: Tot vprop
val has_union_field_prop
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(r: ref (union0 tn n fields))
(field: field_t fields)
(#t': Type0)
(#td': typedef t')
(r': ref td')
: STGhost unit opened
(has_union_field r field r')
(fun _ -> has_union_field r field r')
True
(fun _ ->
t' == fields.fd_type field /\
td' == fields.fd_typedef field
)
val has_union_field_dup
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: nonempty_field_description_t tf)
(r: ref (union0 tn n fields))
(field: field_t fields)
(#t': Type0)
(#td': typedef t')
(r': ref td')
: STGhostT unit opened
(has_union_field r field r')
(fun _ -> has_union_field r field r' `star` has_union_field r field r')
val has_union_field_inj
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: nonempty_field_description_t tf)
(r: ref (union0 tn n fields))
(field: field_t fields)
(#t1: Type0)
(#td1: typedef t1)
(r1: ref td1)
(#t2: Type0)
(#td2: typedef t2)
(r2: ref td2)
: STGhostT (squash (t1 == t2 /\ td1 == td2)) opened
(has_union_field r field r1 `star` has_union_field r field r2)
(fun _ -> has_union_field r field r1 `star` has_union_field r field r2 `star` ref_equiv r1 (coerce_eq () r2))
val has_union_field_equiv_from
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: nonempty_field_description_t tf)
(r1 r2: ref (union0 tn n fields))
(field: field_t fields)
(#t': Type0)
(#td': typedef t')
(r': ref td')
: STGhostT unit opened
(has_union_field r1 field r' `star` ref_equiv r1 r2)
(fun _ -> has_union_field r2 field r' `star` ref_equiv r1 r2)
val has_union_field_equiv_to
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: nonempty_field_description_t tf)
(r: ref (union0 tn n fields))
(field: field_t fields)
(#t': Type0)
(#td': typedef t')
(r1 r2: ref td')
: STGhostT unit opened
(has_union_field r field r1 `star` ref_equiv r1 r2)
(fun _ -> has_union_field r field r2 `star` ref_equiv r1 r2)
val ghost_union_field_focus
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields {union_get_case v == Some field})
(#t': Type0)
(#td': typedef t')
(r': ref td')
: STGhostT (squash (
t' == fields.fd_type field /\
td' == fields.fd_typedef field
)) opened
(has_union_field r field r' `star` pts_to r v)
(fun _ -> has_union_field r field r' `star` pts_to r' (Ghost.hide (coerce_eq () (union_get_field v field))))
val ghost_union_field
(#opened: _)
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields {union_get_case v == Some field})
: STGhostT (Ghost.erased (ref (fields.fd_typedef field))) opened
(pts_to r v)
(fun r' -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
[@@noextract_to "krml"] // primitive
val union_field0
(#tn: Type0)
(#tf: Type0)
(t': Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields {union_get_case v == Some field})
(td': typedef t' {
t' == fields.fd_type field /\
td' == fields.fd_typedef field
})
: STT (ref td')
(pts_to r v)
(fun r' -> has_union_field r field r' `star` pts_to r' (Ghost.hide (coerce_eq () (union_get_field v field)))) | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.C.Types.Fields.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.C.Typestring.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.ST.C.Types.Union.fsti"
} | [
{
"abbrev": true,
"full_module": "Steel.FractionalPermission",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Steel.C.Typestring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.C.Types.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.C.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.C.Types",
"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 |
t': Type0 ->
r: Steel.ST.C.Types.Base.ref (Steel.ST.C.Types.Union.union0 tn n fields) ->
field:
Steel.ST.C.Types.Fields.field_t fields
{ Steel.ST.C.Types.Union.union_get_case (FStar.Ghost.reveal v) ==
FStar.Pervasives.Native.Some field } ->
td': Steel.ST.C.Types.Base.typedef t' ->
sq_t': Prims.squash (t' == Mkfield_description_t?.fd_type fields field) ->
sq_td': Prims.squash (td' == Mkfield_description_t?.fd_typedef fields field)
-> Steel.ST.Effect.STT (Steel.ST.C.Types.Base.ref td') | Steel.ST.Effect.STT | [] | [] | [
"Prims.string",
"Steel.ST.C.Types.Fields.field_description_t",
"FStar.Ghost.erased",
"Steel.ST.C.Types.Union.union_t0",
"Steel.ST.C.Types.Base.ref",
"Steel.ST.C.Types.Union.union0",
"Steel.ST.C.Types.Fields.field_t",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"Steel.ST.C.Types.Union.union_get_case",
"FStar.Ghost.reveal",
"FStar.Pervasives.Native.Some",
"Steel.ST.C.Types.Base.typedef",
"Prims.squash",
"Steel.ST.C.Types.Fields.__proj__Mkfield_description_t__item__fd_type",
"Steel.ST.C.Types.Fields.__proj__Mkfield_description_t__item__fd_typedef",
"Steel.ST.C.Types.Union.union_field0",
"Steel.ST.C.Types.Base.pts_to",
"Steel.Effect.Common.star",
"Steel.ST.C.Types.Union.has_union_field",
"FStar.Ghost.hide",
"Steel.ST.C.Types.Union.union_get_field",
"Steel.Effect.Common.vprop"
] | [] | false | true | false | false | false | let union_field1
(#tn #tf t': Type0)
(#n: string)
(#fields: field_description_t tf)
(#v: Ghost.erased (union_t0 tn n fields))
(r: ref (union0 tn n fields))
(field: field_t fields {union_get_case v == Some field})
(td': typedef t')
(sq_t': squash (t' == fields.fd_type field))
(sq_td': squash (td' == fields.fd_typedef field))
: STT (ref td')
(pts_to r v)
(fun r' -> (has_union_field r field r') `star` (pts_to r' (union_get_field v field))) =
| union_field0 t' r field td' | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.map_fst_flip | val map_fst_flip (#a #b: Type) (l: list (a * b))
: Lemma (list_map fst (list_map flip l) == list_map snd l) | val map_fst_flip (#a #b: Type) (l: list (a * b))
: Lemma (list_map fst (list_map flip l) == list_map snd l) | let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 28,
"end_line": 55,
"start_col": 0,
"start_line": 51
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | l: Prims.list (a * b)
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Enum.list_map FStar.Pervasives.Native.fst
(LowParse.Spec.Enum.list_map LowParse.Spec.Enum.flip l) ==
LowParse.Spec.Enum.list_map FStar.Pervasives.Native.snd l) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.map_fst_flip",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.l_or",
"FStar.List.Tot.Base.map",
"FStar.Pervasives.Native.snd",
"FStar.Pervasives.Native.fst",
"LowParse.Spec.Enum.list_map",
"LowParse.Spec.Enum.flip",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec map_fst_flip (#a #b: Type) (l: list (a * b))
: Lemma (list_map fst (list_map flip l) == list_map snd l) =
| match l with
| [] -> ()
| _ :: q -> map_fst_flip q | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.assoc_flip_intro | val assoc_flip_intro (#a #b: eqtype) (l: list (a * b)) (y: b) (x: a)
: Lemma
(requires
(L.noRepeats (list_map fst l) /\ L.noRepeats (list_map snd l) /\ L.assoc x l == Some y))
(ensures (L.assoc y (list_map flip l) == Some x)) | val assoc_flip_intro (#a #b: eqtype) (l: list (a * b)) (y: b) (x: a)
: Lemma
(requires
(L.noRepeats (list_map fst l) /\ L.noRepeats (list_map snd l) /\ L.assoc x l == Some y))
(ensures (L.assoc y (list_map flip l) == Some x)) | let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 39,
"end_line": 124,
"start_col": 0,
"start_line": 107
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | l: Prims.list (a * b) -> y: b -> x: a
-> FStar.Pervasives.Lemma
(requires
FStar.List.Tot.Base.noRepeats (LowParse.Spec.Enum.list_map FStar.Pervasives.Native.fst l) /\
FStar.List.Tot.Base.noRepeats (LowParse.Spec.Enum.list_map FStar.Pervasives.Native.snd l) /\
FStar.List.Tot.Base.assoc x l == FStar.Pervasives.Native.Some y)
(ensures
FStar.List.Tot.Base.assoc y (LowParse.Spec.Enum.list_map LowParse.Spec.Enum.flip l) ==
FStar.Pervasives.Native.Some x) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.eqtype",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.assoc_flip_elim",
"LowParse.Spec.Enum.list_map",
"LowParse.Spec.Enum.flip",
"Prims.unit",
"LowParse.Spec.Enum.map_flip_flip",
"LowParse.Spec.Enum.map_snd_flip",
"LowParse.Spec.Enum.map_fst_flip",
"Prims.l_and",
"Prims.b2t",
"FStar.List.Tot.Base.noRepeats",
"FStar.Pervasives.Native.fst",
"FStar.Pervasives.Native.snd",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.List.Tot.Base.assoc",
"FStar.Pervasives.Native.Some",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec assoc_flip_intro (#a #b: eqtype) (l: list (a * b)) (y: b) (x: a)
: Lemma
(requires
(L.noRepeats (list_map fst l) /\ L.noRepeats (list_map snd l) /\ L.assoc x l == Some y))
(ensures (L.assoc y (list_map flip l) == Some x)) =
| map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.assoc_flip_elim | val assoc_flip_elim (#a #b: eqtype) (l: list (a * b)) (y: b) (x: a)
: Lemma
(requires
(L.noRepeats (list_map fst l) /\ L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x)) (ensures (L.assoc x l == Some y)) (decreases l) | val assoc_flip_elim (#a #b: eqtype) (l: list (a * b)) (y: b) (x: a)
: Lemma
(requires
(L.noRepeats (list_map fst l) /\ L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x)) (ensures (L.assoc x l == Some y)) (decreases l) | let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 5,
"end_line": 105,
"start_col": 0,
"start_line": 77
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | l: Prims.list (a * b) -> y: b -> x: a
-> FStar.Pervasives.Lemma
(requires
FStar.List.Tot.Base.noRepeats (LowParse.Spec.Enum.list_map FStar.Pervasives.Native.fst l) /\
FStar.List.Tot.Base.noRepeats (LowParse.Spec.Enum.list_map FStar.Pervasives.Native.snd l) /\
FStar.List.Tot.Base.assoc y (LowParse.Spec.Enum.list_map LowParse.Spec.Enum.flip l) ==
FStar.Pervasives.Native.Some x)
(ensures FStar.List.Tot.Base.assoc x l == FStar.Pervasives.Native.Some y)
(decreases l) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"Prims.eqtype",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.op_Equality",
"Prims.bool",
"Prims._assert",
"Prims.l_False",
"Prims.unit",
"LowParse.Spec.Enum.map_snd_flip",
"LowParse.Spec.Enum.assoc_mem_snd",
"LowParse.Spec.Enum.list_map",
"LowParse.Spec.Enum.flip",
"Prims.eq2",
"LowParse.Spec.Enum.list_mem",
"FStar.Pervasives.Native.fst",
"LowParse.Spec.Enum.assoc_flip_elim",
"Prims.l_and",
"Prims.b2t",
"FStar.List.Tot.Base.noRepeats",
"FStar.Pervasives.Native.snd",
"FStar.Pervasives.Native.option",
"FStar.List.Tot.Base.assoc",
"FStar.Pervasives.Native.Some",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec assoc_flip_elim (#a #b: eqtype) (l: list (a * b)) (y: b) (x: a)
: Lemma
(requires
(L.noRepeats (list_map fst l) /\ L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x)) (ensures (L.assoc x l == Some y)) (decreases l) =
| let (x', y') :: l' = l in
if y' = y
then ()
else
if x' = x
then
(assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False)
else assoc_flip_elim l' y x | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.parse_enum_key | val parse_enum_key (#k: parser_kind) (#key #repr: eqtype) (p: parser k repr) (e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e)) | val parse_enum_key (#k: parser_kind) (#key #repr: eqtype) (p: parser k repr) (e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e)) | let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 24,
"end_line": 166,
"start_col": 0,
"start_line": 155
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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: LowParse.Spec.Base.parser k repr -> e: LowParse.Spec.Enum.enum key repr
-> LowParse.Spec.Base.parser (LowParse.Spec.Combinators.parse_filter_kind k)
(LowParse.Spec.Enum.enum_key e) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"Prims.eqtype",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Combinators.parse_synth",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.Enum.parse_enum_key_cond",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Combinators.parse_filter",
"LowParse.Spec.Enum.parse_enum_key_synth"
] | [] | false | false | false | false | false | let parse_enum_key (#k: parser_kind) (#key #repr: eqtype) (p: parser k repr) (e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e)) =
| (p `parse_filter` (parse_enum_key_cond e)) `parse_synth` (parse_enum_key_synth e) | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.is_total_enum | val is_total_enum (#key #repr: eqtype) (l: list (key * repr)) : GTot Type0 | val is_total_enum (#key #repr: eqtype) (l: list (key * repr)) : GTot Type0 | let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l) | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 88,
"end_line": 333,
"start_col": 0,
"start_line": 332
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | l: Prims.list (key * repr) -> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.eqtype",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.l_Forall",
"Prims.b2t",
"LowParse.Spec.Enum.list_mem",
"LowParse.Spec.Enum.list_map",
"FStar.Pervasives.Native.fst"
] | [] | false | false | false | false | true | let is_total_enum (#key #repr: eqtype) (l: list (key * repr)) : GTot Type0 =
| forall (k: key). {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l) | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.serialize_enum_key_synth_recip | val serialize_enum_key_synth_recip (#key #repr: eqtype) (e: enum key repr) (k: enum_key e)
: GTot (r: repr{parse_enum_key_cond e r == true}) | val serialize_enum_key_synth_recip (#key #repr: eqtype) (e: enum key repr) (k: enum_key e)
: GTot (r: repr{parse_enum_key_cond e r == true}) | let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 22,
"end_line": 203,
"start_col": 0,
"start_line": 198
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | e: LowParse.Spec.Enum.enum key repr -> k: LowParse.Spec.Enum.enum_key e
-> Prims.GTot (r: repr{LowParse.Spec.Enum.parse_enum_key_cond e r == true}) | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Enum.enum_repr_of_key",
"Prims.eq2",
"Prims.bool",
"LowParse.Spec.Enum.parse_enum_key_cond"
] | [] | false | false | false | false | false | let serialize_enum_key_synth_recip (#key #repr: eqtype) (e: enum key repr) (k: enum_key e)
: GTot (r: repr{parse_enum_key_cond e r == true}) =
| enum_repr_of_key e k | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.parse_enum_key_synth | val parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr{parse_enum_key_cond e r == true})
: GTot (enum_key e) | val parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr{parse_enum_key_cond e r == true})
: GTot (enum_key e) | let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 22,
"end_line": 153,
"start_col": 0,
"start_line": 148
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | e: LowParse.Spec.Enum.enum key repr -> r: repr{LowParse.Spec.Enum.parse_enum_key_cond e r == true}
-> Prims.GTot (LowParse.Spec.Enum.enum_key e) | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.eq2",
"Prims.bool",
"LowParse.Spec.Enum.parse_enum_key_cond",
"LowParse.Spec.Enum.enum_key_of_repr",
"LowParse.Spec.Enum.enum_key"
] | [] | false | false | false | false | false | let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr{parse_enum_key_cond e r == true})
: GTot (enum_key e) =
| enum_key_of_repr e r | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.synth_total_enum_key | val synth_total_enum_key (#key #repr: eqtype) (l: total_enum key repr) (k: enum_key l) : Tot key | val synth_total_enum_key (#key #repr: eqtype) (l: total_enum key repr) (k: enum_key l) : Tot key | let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k' | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 4,
"end_line": 345,
"start_col": 0,
"start_line": 338
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } ) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | l: LowParse.Spec.Enum.total_enum key repr -> k: LowParse.Spec.Enum.enum_key l -> key | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.total_enum",
"LowParse.Spec.Enum.enum_key"
] | [] | false | false | false | false | false | let synth_total_enum_key (#key #repr: eqtype) (l: total_enum key repr) (k: enum_key l) : Tot key =
| let k':key = k in
k' | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.enum_repr_of_key | val enum_repr_of_key (#key #repr: eqtype) (e: enum key repr) (k: enum_key e)
: Pure (enum_repr e) (requires True) (ensures (fun r -> L.assoc k e == Some r)) | val enum_repr_of_key (#key #repr: eqtype) (e: enum key repr) (k: enum_key e)
: Pure (enum_repr e) (requires True) (ensures (fun r -> L.assoc k e == Some r)) | let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e) | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 20,
"end_line": 180,
"start_col": 0,
"start_line": 168
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | e: LowParse.Spec.Enum.enum key repr -> k: LowParse.Spec.Enum.enum_key e
-> Prims.Pure (LowParse.Spec.Enum.enum_repr e) | Prims.Pure | [] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Enum.enum_repr",
"Prims.unit",
"LowParse.Spec.Enum.map_fst_flip",
"FStar.List.Tot.Properties.assoc_mem",
"LowParse.Spec.Enum.list_map",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.flip",
"LowParse.Spec.Enum.assoc_flip_intro",
"FStar.Pervasives.Native.__proj__Some__item__v",
"FStar.List.Tot.Base.assoc",
"Prims.l_True",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.Some"
] | [] | false | false | false | false | false | let enum_repr_of_key (#key #repr: eqtype) (e: enum key repr) (k: enum_key e)
: Pure (enum_repr e) (requires True) (ensures (fun r -> L.assoc k e == Some r)) =
| L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e) | false |
Pulse.Checker.Prover.Substs.fst | Pulse.Checker.Prover.Substs.ss_to_nt_substs | val ss_to_nt_substs (g:env) (uvs:env) (ss:ss_t)
: T.Tac (either (nts:nt_substs &
effect_labels:list T.tot_or_ghost {
well_typed_nt_substs g uvs nts effect_labels /\
is_permutation nts ss
})
string) | val ss_to_nt_substs (g:env) (uvs:env) (ss:ss_t)
: T.Tac (either (nts:nt_substs &
effect_labels:list T.tot_or_ghost {
well_typed_nt_substs g uvs nts effect_labels /\
is_permutation nts ss
})
string) | let rec ss_to_nt_substs (g:env) (uvs:env) (ss:ss_t)
: T.Tac (either (nts:nt_substs &
effect_labels:list T.tot_or_ghost {
well_typed_nt_substs g uvs nts effect_labels /\
is_permutation nts ss
})
string) =
let g = Env.push_context g "ss_to_nt_substs" (range_of_env g) in
match bindings uvs with
| [] ->
(match ss.l with
| [] -> Inl (| [], [] |)
| x::_ ->
Inr (Printf.sprintf "extra uvars in the substitutions collected by the prover, e.g._#%d" x))
| _ ->
let x, ty, rest_uvs = remove_binding uvs in
if Map.contains ss.m x
then let t = Map.sel ss.m x in
let (| eff, d |) = core_check_term_at_type g t ty in
let _ = FStar.Squash.return_squash d in
let ropt =
ss_to_nt_substs g (subst_env rest_uvs [ NT x t ]) {l=remove_l ss.l x;
m=remove_map ss.m x} in
match ropt with
| Inr e -> Inr e
| Inl (| nts, effect_labels |) ->
let r : (nts:nt_substs &
effect_labels:list T.tot_or_ghost {
well_typed_nt_substs g uvs nts effect_labels /\
is_permutation nts ss
}) = (| (NT x t)::nts, eff::effect_labels |) in
Inl r
else Inr (Printf.sprintf "prover could not prove uvar _#%d" x) | {
"file_name": "lib/steel/pulse/Pulse.Checker.Prover.Substs.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 66,
"end_line": 315,
"start_col": 0,
"start_line": 282
} | (*
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 Pulse.Checker.Prover.Substs
open FStar.List.Tot
open Pulse.Syntax
open Pulse.Typing.Env
open Pulse.Typing
open Pulse.Checker.Pure
module L = FStar.List.Tot
module Env = Pulse.Typing.Env
module Metatheory = Pulse.Typing.Metatheory
let coerce_eq (#a #b:Type) (x:a) (_:squash (a == b)) : y:b {y == x} = x
let rec no_repeats (l:list var) : Type0 =
match l with
| [] -> True
| x::tl -> (~ (L.memP x tl)) /\ no_repeats tl
type ss_dom = l:list var { no_repeats l }
type ss_map = m:Map.t var term {
forall (x:var). (~ (Map.contains m x)) ==> Map.sel m x == tm_unknown
}
let remove_map (m:ss_map) (x:var) =
Map.restrict (Set.complement (Set.singleton x)) (Map.upd m x tm_unknown)
let rec is_dom (l:ss_dom) (m:ss_map) : Type0 =
match l with
| [] -> Set.equal (Map.domain m) Set.empty
| x::tl ->
Map.contains m x /\ is_dom tl (remove_map m x)
let rec is_dom_mem (l:ss_dom) (m:ss_map)
: Lemma
(requires is_dom l m)
(ensures forall (x:var).{:pattern L.memP x l \/ Map.contains m x}
L.memP x l <==> Map.contains m x)
[SMTPat (is_dom l m)] =
match l with
| [] -> ()
| y::tl -> is_dom_mem tl (remove_map m y)
noeq
type ss_t = {
l : ss_dom;
m : m:ss_map { is_dom l m }
}
let ln_ss_t (s:ss_t) =
List.Tot.for_all (fun x -> ln (Map.sel s.m x)) s.l
let as_map (ss:ss_t) = ss.m
let empty = { l = []; m = Map.const_on Set.empty tm_unknown }
let is_dom_push
(l:ss_dom)
(m:ss_map { is_dom l m })
(x:var { ~ (Map.contains m x ) })
(t:term)
: Lemma (is_dom (x::l) (Map.upd m x t)) =
assert (Map.equal (remove_map (Map.upd m x t) x) m)
let push (ss:ss_t) (x:var { ~ (contains ss x) }) (t:term) : ss_t =
is_dom_push ss.l ss.m x t;
{ l = x::ss.l;
m = Map.upd ss.m x t }
let tail (ss:ss_t { Cons? ss.l }) : ss_t =
{ l = L.tl ss.l; m = remove_map ss.m (L.hd ss.l) }
let rec push_ss (ss1:ss_t) (ss2:ss_t { Set.disjoint (dom ss1) (dom ss2) })
: Tot ss_t (decreases L.length ss2.l) =
match ss2.l with
| [] -> ss1
| x::tl ->
push_ss (push ss1 x (Map.sel ss2.m x)) (tail ss2)
let check_disjoint ss1 ss2 =
admit ();
not (L.existsb (fun v1 -> L.mem v1 ss2.l) ss1.l)
let rec diff_aux (ss1 ss2:ss_t) (acc:ss_t { Set.disjoint (dom acc) (dom ss2) })
: Tot (ss:ss_t { Set.disjoint (dom ss) (dom ss2) }) (decreases L.length ss1.l) =
match ss1.l with
| [] -> acc
| x::l ->
if L.mem x ss2.l
then let ss1 = { ss1 with l; m = remove_map ss1.m x } in
diff_aux ss1 ss2 acc
else let acc_l = x::acc.l in
let acc_m = Map.upd acc.m x (Map.sel ss1.m x) in
assume (no_repeats acc_l /\ is_dom acc_l acc_m);
let acc = { l = acc_l; m = acc_m } in
let ss1 = { ss1 with l; m = remove_map ss1.m x } in
diff_aux ss1 ss2 acc
let diff ss1 ss2 = diff_aux ss1 ss2 empty
#push-options "--warn_error -271"
let push_as_map (ss1 ss2:ss_t)
: Lemma (requires Set.disjoint (dom ss1) (dom ss2))
(ensures Map.equal (as_map (push_ss ss1 ss2))
(Map.concat (as_map ss1) (as_map ss2)))
(decreases L.length ss2.l)
[SMTPat (as_map (push_ss ss1 ss2))] =
let rec aux (ss1 ss2:ss_t)
: Lemma (requires Set.disjoint (dom ss1) (dom ss2))
(ensures Map.equal (as_map (push_ss ss1 ss2))
(Map.concat (as_map ss1) (as_map ss2)))
(decreases L.length ss2.l)
[SMTPat ()] =
match ss2.l with
| [] -> ()
| x::tl -> aux (push ss1 x (Map.sel ss2.m x)) (tail ss2)
in
()
#pop-options
let rec remove_l (l:ss_dom) (x:var { L.memP x l })
: Pure ss_dom
(requires True)
(ensures fun r -> forall (y:var). L.memP y r <==> (L.memP y l /\ y =!= x)) =
match l with
| [] -> assert False; []
| y::tl ->
if y = x then tl
else y::(remove_l tl x)
let rec is_dom_remove
(l:ss_dom)
(m:ss_map { is_dom l m })
(x:var { Map.contains m x })
: Lemma (is_dom (remove_l l x) (remove_map m x))
[SMTPat (remove_l l x); SMTPat (remove_map m x)] =
match l with
| [] -> ()
| y::tl ->
if x = y then ()
else let t_y = Map.sel m y in
let m1 = remove_map m y in
is_dom_remove tl m1 x;
assert (is_dom (remove_l tl x) (remove_map m1 x));
is_dom_push (remove_l tl x) (remove_map m1 x) y t_y;
assert (Map.equal (Map.upd (remove_map m1 x) y t_y)
(remove_map m x))
let rec ss_term (t:term) (ss:ss_t) : Tot term (decreases L.length ss.l) =
match ss.l with
| [] -> t
| y::tl ->
let t = subst_term t [ NT y (Map.sel ss.m y) ] in
ss_term t (tail ss)
let rec ss_st_term (t:st_term) (ss:ss_t) : Tot st_term (decreases L.length ss.l) =
match ss.l with
| [] -> t
| y::tl ->
let t = subst_st_term t [ NT y (Map.sel ss.m y) ] in
ss_st_term t (tail ss)
let rec ss_st_comp (s:st_comp) (ss:ss_t)
: Tot st_comp (decreases L.length ss.l) =
match ss.l with
| [] -> s
| y::tl ->
let s = subst_st_comp s [ NT y (Map.sel ss.m y) ] in
ss_st_comp s (tail ss)
let rec ss_comp (c:comp) (ss:ss_t)
: Tot comp (decreases L.length ss.l) =
match ss.l with
| [] -> c
| y::tl ->
let c = subst_comp c [ NT y (Map.sel ss.m y) ] in
ss_comp c (tail ss)
let rec ss_binder (b:binder) (ss:ss_t)
: Tot binder (decreases L.length ss.l) =
match ss.l with
| [] -> b
| y::tl ->
let b = subst_binder b [ NT y (Map.sel ss.m y) ] in
ss_binder b (tail ss)
let rec ss_env (g:env) (ss:ss_t)
: Tot (g':env { fstar_env g' == fstar_env g /\
Env.dom g' == Env.dom g })
(decreases L.length ss.l) =
admit ();
match ss.l with
| [] -> g
| y::tl -> ss_env (subst_env g [ NT y (Map.sel ss.m y) ]) (tail ss)
let rec ss_st_comp_commutes (s:st_comp) (ss:ss_t)
: Lemma (ensures
ss_st_comp s ss ==
{ s with res = ss_term s.res ss;
pre = ss_term s.pre ss;
post = ss_term s.post ss; }) // no shifting required
(decreases L.length ss.l)
[SMTPat (ss_st_comp s ss)] =
match ss.l with
| [] -> ()
| y::tl -> ss_st_comp_commutes (subst_st_comp s [ NT y (Map.sel ss.m y) ]) (tail ss)
let rec ss_comp_commutes (c:comp) (ss:ss_t)
: Lemma (ensures
(let r = ss_comp c ss in
(C_Tot? c ==> r == C_Tot (ss_term (comp_res c) ss)) /\
(C_ST? c ==> r == C_ST (ss_st_comp (st_comp_of_comp c) ss)) /\
(C_STAtomic? c ==> r == C_STAtomic (ss_term (comp_inames c) ss)
(C_STAtomic?.obs c)
(ss_st_comp (st_comp_of_comp c) ss)) /\
(C_STGhost? c ==> r == C_STGhost (ss_st_comp (st_comp_of_comp c) ss))))
(decreases L.length ss.l)
[SMTPat (ss_comp c ss)] =
match ss.l with
| [] -> ()
| y::tl -> ss_comp_commutes (subst_comp c [ NT y (Map.sel ss.m y) ]) (tail ss)
let rec nt_substs_st_comp_commutes (s:st_comp) (nts:nt_substs)
: Lemma (ensures
nt_subst_st_comp s nts ==
{ s with res = nt_subst_term s.res nts;
pre = nt_subst_term s.pre nts;
post = nt_subst_term s.post nts; }) // no shifting required
(decreases nts)
[SMTPat (nt_subst_st_comp s nts)] =
match nts with
| [] -> ()
| (NT x e)::nts_tl -> nt_substs_st_comp_commutes (nt_subst_st_comp s [ NT x e ]) nts_tl
let rec nt_subst_comp_commutes (c:comp) (nts:nt_substs)
: Lemma (ensures
(let r = nt_subst_comp c nts in
(C_Tot? c ==> r == C_Tot (nt_subst_term (comp_res c) nts)) /\
(C_ST? c ==> r == C_ST (nt_subst_st_comp (st_comp_of_comp c) nts)) /\
(C_STAtomic? c ==> r == C_STAtomic (nt_subst_term (comp_inames c) nts)
(C_STAtomic?.obs c)
(nt_subst_st_comp (st_comp_of_comp c) nts)) /\
(C_STGhost? c ==> r == C_STGhost (nt_subst_st_comp (st_comp_of_comp c) nts))))
(decreases nts)
[SMTPat (nt_subst_comp c nts)] =
match nts with
| [] -> ()
| (NT x e)::nts_tl -> nt_subst_comp_commutes (nt_subst_comp c [ NT x e ]) nts_tl
let rec is_permutation (nts:nt_substs) (ss:ss_t) : Type0 =
match nts, ss.l with
| [], [] -> True
| (NT x e)::nts_rest, _::_ ->
Map.contains ss.m x /\
Map.sel ss.m x == e /\
is_permutation nts_rest ({l=remove_l ss.l x; m=remove_map ss.m x})
| _ -> False | {
"checked_file": "/",
"dependencies": [
"Pulse.Typing.Metatheory.fsti.checked",
"Pulse.Typing.Env.fsti.checked",
"Pulse.Typing.fst.checked",
"Pulse.Syntax.fst.checked",
"Pulse.Checker.Pure.fsti.checked",
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked"
],
"interface_file": true,
"source_file": "Pulse.Checker.Prover.Substs.fst"
} | [
{
"abbrev": true,
"full_module": "Pulse.Typing.Metatheory",
"short_module": "Metatheory"
},
{
"abbrev": true,
"full_module": "Pulse.Typing.Env",
"short_module": "Env"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing.Env",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": true,
"full_module": "Pulse.Typing.Env",
"short_module": "Env"
},
{
"abbrev": true,
"full_module": "FStar.Tactics",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing.Env",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Prover",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Prover",
"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 | g: Pulse.Typing.Env.env -> uvs: Pulse.Typing.Env.env -> ss: Pulse.Checker.Prover.Substs.ss_t
-> FStar.Tactics.Effect.Tac
(FStar.Pervasives.either (Prims.dtuple2 Pulse.Checker.Prover.Substs.nt_substs
(fun nts ->
effect_labels:
Prims.list FStar.Stubs.TypeChecker.Core.tot_or_ghost
{ Pulse.Checker.Prover.Substs.well_typed_nt_substs g uvs nts effect_labels /\
Pulse.Checker.Prover.Substs.is_permutation nts ss }))
Prims.string) | FStar.Tactics.Effect.Tac | [] | [] | [
"Pulse.Typing.Env.env",
"Pulse.Checker.Prover.Substs.ss_t",
"Pulse.Typing.Env.bindings",
"Pulse.Checker.Prover.Substs.__proj__Mkss_t__item__l",
"FStar.Pervasives.Inl",
"Prims.dtuple2",
"Pulse.Checker.Prover.Substs.nt_substs",
"Prims.list",
"FStar.Stubs.TypeChecker.Core.tot_or_ghost",
"Prims.l_and",
"Pulse.Checker.Prover.Substs.well_typed_nt_substs",
"Pulse.Checker.Prover.Substs.is_permutation",
"Prims.string",
"Prims.Mkdtuple2",
"Prims.Nil",
"Pulse.Syntax.Naming.subst_elt",
"Pulse.Syntax.Base.var",
"FStar.Pervasives.Inr",
"FStar.Printf.sprintf",
"FStar.Pervasives.either",
"Pulse.Typing.Env.binding",
"Pulse.Syntax.Base.typ",
"FStar.Map.contains",
"Pulse.Syntax.Base.term",
"Pulse.Checker.Prover.Substs.__proj__Mkss_t__item__m",
"Pulse.Typing.typing",
"Pulse.Typing.Env.subst_env",
"Prims.Cons",
"Pulse.Syntax.Naming.NT",
"Pulse.Checker.Prover.Substs.Mkss_t",
"Pulse.Checker.Prover.Substs.remove_l",
"Pulse.Checker.Prover.Substs.remove_map",
"Pulse.Checker.Prover.Substs.ss_to_nt_substs",
"Prims.squash",
"FStar.Squash.return_squash",
"Pulse.Checker.Pure.core_check_term_at_type",
"FStar.Map.sel",
"Prims.bool",
"FStar.Pervasives.Native.tuple3",
"Pulse.Typing.Env.remove_binding",
"Prims.eq2",
"Pulse.Typing.Env.push_context",
"Pulse.Syntax.Base.range",
"Pulse.Typing.Env.range_of_env"
] | [
"recursion"
] | false | true | false | false | false | let rec ss_to_nt_substs (g uvs: env) (ss: ss_t)
: T.Tac
(either (nts: nt_substs &
effect_labels:
list T.tot_or_ghost
{well_typed_nt_substs g uvs nts effect_labels /\ is_permutation nts ss})
string) =
| let g = Env.push_context g "ss_to_nt_substs" (range_of_env g) in
match bindings uvs with
| [] ->
(match ss.l with
| [] -> Inl (| [], [] |)
| x :: _ ->
Inr (Printf.sprintf "extra uvars in the substitutions collected by the prover, e.g._#%d" x))
| _ ->
let x, ty, rest_uvs = remove_binding uvs in
if Map.contains ss.m x
then
let t = Map.sel ss.m x in
let (| eff , d |) = core_check_term_at_type g t ty in
let _ = FStar.Squash.return_squash d in
let ropt =
ss_to_nt_substs g
(subst_env rest_uvs [NT x t])
({ l = remove_l ss.l x; m = remove_map ss.m x })
in
match ropt with
| Inr e -> Inr e
| Inl (| nts , effect_labels |) ->
let r:(nts: nt_substs &
effect_labels:
list T.tot_or_ghost {well_typed_nt_substs g uvs nts effect_labels /\ is_permutation nts ss})
=
(| (NT x t) :: nts, eff :: effect_labels |)
in
Inl r
else Inr (Printf.sprintf "prover could not prove uvar _#%d" x) | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.serialize_enum_key | val serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e)) | val serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e)) | let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
() | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 6,
"end_line": 225,
"start_col": 0,
"start_line": 212
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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: LowParse.Spec.Base.parser k repr ->
s: LowParse.Spec.Base.serializer p ->
e: LowParse.Spec.Enum.enum key repr
-> LowParse.Spec.Base.serializer (LowParse.Spec.Enum.parse_enum_key p e) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"Prims.eqtype",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Combinators.serialize_synth",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.Enum.parse_enum_key_cond",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Combinators.parse_filter",
"LowParse.Spec.Enum.parse_enum_key_synth",
"LowParse.Spec.Combinators.serialize_filter",
"LowParse.Spec.Enum.serialize_enum_key_synth_recip",
"Prims.unit",
"LowParse.Spec.Enum.serialize_enum_key_synth_inverse",
"LowParse.Spec.Enum.parse_enum_key"
] | [] | false | false | false | false | false | let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e)) =
| serialize_enum_key_synth_inverse e;
serialize_synth (parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
() | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.serialize_enum_key_synth_inverse | val serialize_enum_key_synth_inverse (#key #repr: eqtype) (e: enum key repr)
: Lemma (synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e)) | val serialize_enum_key_synth_inverse (#key #repr: eqtype) (e: enum key repr)
: Lemma (synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e)) | let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e) | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 52,
"end_line": 210,
"start_col": 0,
"start_line": 205
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | e: LowParse.Spec.Enum.enum key repr
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Combinators.synth_inverse (LowParse.Spec.Enum.parse_enum_key_synth e)
(LowParse.Spec.Enum.serialize_enum_key_synth_recip e)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"FStar.Classical.forall_intro",
"LowParse.Spec.Enum.enum_key",
"Prims.eq2",
"LowParse.Spec.Enum.enum_key_of_repr",
"LowParse.Spec.Enum.enum_repr_of_key",
"LowParse.Spec.Enum.enum_key_of_repr_of_key",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"LowParse.Spec.Combinators.synth_inverse",
"Prims.bool",
"LowParse.Spec.Enum.parse_enum_key_cond",
"LowParse.Spec.Enum.parse_enum_key_synth",
"LowParse.Spec.Enum.serialize_enum_key_synth_recip",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let serialize_enum_key_synth_inverse (#key #repr: eqtype) (e: enum key repr)
: Lemma (synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e)) =
| Classical.forall_intro (enum_key_of_repr_of_key e) | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.r_reflexive_prop | val r_reflexive_prop (t: Type) (r: (t -> t -> GTot Type0)) : GTot Type0 | val r_reflexive_prop (t: Type) (r: (t -> t -> GTot Type0)) : GTot Type0 | let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 42,
"end_line": 464,
"start_col": 0,
"start_line": 460
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | t: Type -> r: (_: t -> _: t -> Prims.GTot Type0) -> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.l_Forall"
] | [] | false | false | false | false | true | let r_reflexive_prop (t: Type) (r: (t -> t -> GTot Type0)) : GTot Type0 =
| forall (x: t). {:pattern (r x x)} r x x | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.serialize_maybe_enum_key_eq | val serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x)) | val serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x)) | let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 83,
"end_line": 330,
"start_col": 0,
"start_line": 321
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 |
s: LowParse.Spec.Base.serializer p ->
e: LowParse.Spec.Enum.enum key repr ->
x: LowParse.Spec.Enum.maybe_enum_key e
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Base.serialize (LowParse.Spec.Enum.serialize_maybe_enum_key p s e) x ==
LowParse.Spec.Base.serialize s (LowParse.Spec.Enum.repr_of_maybe_enum_key e x)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"Prims.eqtype",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.maybe_enum_key",
"LowParse.Spec.Combinators.serialize_synth_eq",
"LowParse.Spec.Enum.maybe_enum_key_of_repr",
"LowParse.Spec.Enum.repr_of_maybe_enum_key",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.serialize",
"LowParse.Spec.Enum.parse_maybe_enum_key",
"LowParse.Spec.Enum.serialize_maybe_enum_key",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x)) =
| serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.enum_key_of_repr_of_key | val enum_key_of_repr_of_key (#key #repr: eqtype) (e: enum key repr) (k: enum_key e)
: Lemma (enum_key_of_repr e (enum_repr_of_key e k) == k) | val enum_key_of_repr_of_key (#key #repr: eqtype) (e: enum key repr) (k: enum_key e)
: Lemma (enum_key_of_repr e (enum_repr_of_key e k) == k) | let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 45,
"end_line": 196,
"start_col": 0,
"start_line": 190
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | e: LowParse.Spec.Enum.enum key repr -> k: LowParse.Spec.Enum.enum_key e
-> FStar.Pervasives.Lemma
(ensures LowParse.Spec.Enum.enum_key_of_repr e (LowParse.Spec.Enum.enum_repr_of_key e k) == k) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Enum.assoc_flip_intro",
"LowParse.Spec.Enum.enum_repr_of_key",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"LowParse.Spec.Enum.enum_key_of_repr",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let enum_key_of_repr_of_key (#key #repr: eqtype) (e: enum key repr) (k: enum_key e)
: Lemma (enum_key_of_repr e (enum_repr_of_key e k) == k) =
| assoc_flip_intro e (enum_repr_of_key e k) k | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.r_transitive_prop | val r_transitive_prop (t: Type) (r: (t -> t -> GTot Type0)) : GTot Type0 | val r_transitive_prop (t: Type) (r: (t -> t -> GTot Type0)) : GTot Type0 | let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 76,
"end_line": 485,
"start_col": 0,
"start_line": 481
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | t: Type -> r: (_: t -> _: t -> Prims.GTot Type0) -> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.l_Forall",
"Prims.l_imp",
"Prims.l_and"
] | [] | false | false | false | false | true | let r_transitive_prop (t: Type) (r: (t -> t -> GTot Type0)) : GTot Type0 =
| forall (x: t) (y: t) (z: t). {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.serialize_enum_key_eq | val serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma (serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x)) | val serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma (serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x)) | let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 5,
"end_line": 243,
"start_col": 0,
"start_line": 227
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
() | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 |
s: LowParse.Spec.Base.serializer p ->
e: LowParse.Spec.Enum.enum key repr ->
x: LowParse.Spec.Enum.enum_key e
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Base.serialize (LowParse.Spec.Enum.serialize_enum_key p s e) x ==
LowParse.Spec.Base.serialize s (LowParse.Spec.Enum.enum_repr_of_key e x)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"Prims.eqtype",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Combinators.serialize_synth_eq",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.Enum.parse_enum_key_cond",
"LowParse.Spec.Combinators.parse_filter",
"LowParse.Spec.Enum.parse_enum_key_synth",
"LowParse.Spec.Combinators.serialize_filter",
"LowParse.Spec.Enum.serialize_enum_key_synth_recip",
"Prims.unit",
"LowParse.Spec.Enum.serialize_enum_key_synth_inverse",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.serialize",
"LowParse.Spec.Enum.parse_enum_key",
"LowParse.Spec.Enum.serialize_enum_key",
"LowParse.Spec.Enum.enum_repr_of_key",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma (serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x)) =
| serialize_enum_key_synth_inverse e;
serialize_synth_eq (parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.parse_enum_key_eq | val parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input ==
(match parse p input with
| Some (x, consumed) ->
(match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None)
| _ -> None)) | val parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input ==
(match parse p input with
| Some (x, consumed) ->
(match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None)
| _ -> None)) | let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 88,
"end_line": 299,
"start_col": 0,
"start_line": 283
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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: LowParse.Spec.Base.parser k repr ->
e: LowParse.Spec.Enum.enum key repr ->
input: LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Base.parse (LowParse.Spec.Enum.parse_enum_key p e) input ==
(match LowParse.Spec.Base.parse p input with
| FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ x consumed) ->
(match LowParse.Spec.Enum.maybe_enum_key_of_repr e x with
| LowParse.Spec.Enum.Known #_ #_ #_ k -> FStar.Pervasives.Native.Some (k, consumed)
| _ -> FStar.Pervasives.Native.None)
<:
FStar.Pervasives.Native.option (LowParse.Spec.Enum.enum_key e *
LowParse.Spec.Base.consumed_length input)
| _ -> FStar.Pervasives.Native.None)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"Prims.eqtype",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Enum.enum",
"LowParse.Bytes.bytes",
"LowParse.Spec.Combinators.parse_synth_eq",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.Enum.parse_enum_key_cond",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Combinators.parse_filter",
"LowParse.Spec.Enum.parse_enum_key_synth",
"Prims.unit",
"LowParse.Spec.Combinators.parse_filter_eq",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.Base.parse",
"LowParse.Spec.Enum.parse_enum_key",
"LowParse.Spec.Enum.maybe_enum_key_of_repr",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.Mktuple2",
"LowParse.Spec.Enum.maybe_enum_key",
"FStar.Pervasives.Native.None",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input ==
(match parse p input with
| Some (x, consumed) ->
(match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None)
| _ -> None)) =
| parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` (parse_enum_key_cond e)) (parse_enum_key_synth e) input | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.repr_of_maybe_enum_key | val repr_of_maybe_enum_key (#key #repr: eqtype) (e: enum key repr) (x: maybe_enum_key e)
: Tot (r: repr{maybe_enum_key_of_repr e r == x}) | val repr_of_maybe_enum_key (#key #repr: eqtype) (e: enum key repr) (x: maybe_enum_key e)
: Tot (r: repr{maybe_enum_key_of_repr e r == x}) | let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 18,
"end_line": 310,
"start_col": 0,
"start_line": 301
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | e: LowParse.Spec.Enum.enum key repr -> x: LowParse.Spec.Enum.maybe_enum_key e
-> r: repr{LowParse.Spec.Enum.maybe_enum_key_of_repr e r == x} | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.maybe_enum_key",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Enum.enum_repr_of_key",
"Prims.unit",
"LowParse.Spec.Enum.enum_key_of_repr_of_key",
"LowParse.Spec.Enum.unknown_enum_repr",
"Prims.eq2",
"LowParse.Spec.Enum.maybe_enum_key_of_repr"
] | [] | false | false | false | false | false | let repr_of_maybe_enum_key (#key #repr: eqtype) (e: enum key repr) (x: maybe_enum_key e)
: Tot (r: repr{maybe_enum_key_of_repr e r == x}) =
| match x with
| Known k' ->
enum_key_of_repr_of_key e k';
enum_repr_of_key e k'
| Unknown r -> r | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.synth_total_enum_key_recip | val synth_total_enum_key_recip (#key #repr: eqtype) (l: total_enum key repr) (k: key)
: Tot (k': enum_key l {synth_total_enum_key l k' == k}) | val synth_total_enum_key_recip (#key #repr: eqtype) (l: total_enum key repr) (k: key)
: Tot (k': enum_key l {synth_total_enum_key l k' == k}) | let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 362,
"start_col": 0,
"start_line": 356
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | l: LowParse.Spec.Enum.total_enum key repr -> k: key
-> k': LowParse.Spec.Enum.enum_key l {LowParse.Spec.Enum.synth_total_enum_key l k' == k} | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.total_enum",
"LowParse.Spec.Enum.enum_key",
"Prims.eq2",
"LowParse.Spec.Enum.synth_total_enum_key"
] | [] | false | false | false | false | false | let synth_total_enum_key_recip (#key #repr: eqtype) (l: total_enum key repr) (k: key)
: Tot (k': enum_key l {synth_total_enum_key l k' == k}) =
| k | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.serialize_maybe_enum_key | val serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e)) | val serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e)) | let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 78,
"end_line": 319,
"start_col": 0,
"start_line": 312
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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: LowParse.Spec.Base.parser k repr ->
s: LowParse.Spec.Base.serializer p ->
e: LowParse.Spec.Enum.enum key repr
-> LowParse.Spec.Base.serializer (LowParse.Spec.Enum.parse_maybe_enum_key p e) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"Prims.eqtype",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Combinators.serialize_synth",
"LowParse.Spec.Enum.maybe_enum_key",
"LowParse.Spec.Enum.maybe_enum_key_of_repr",
"LowParse.Spec.Enum.repr_of_maybe_enum_key",
"LowParse.Spec.Enum.parse_maybe_enum_key"
] | [] | false | false | false | false | false | let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e)) =
| serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.parse_maybe_enum_key | val parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e)) | val parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e)) | let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e) | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 44,
"end_line": 268,
"start_col": 0,
"start_line": 262
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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: LowParse.Spec.Base.parser k repr -> e: LowParse.Spec.Enum.enum key repr
-> LowParse.Spec.Base.parser k (LowParse.Spec.Enum.maybe_enum_key e) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"Prims.eqtype",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Combinators.parse_synth",
"LowParse.Spec.Enum.maybe_enum_key",
"LowParse.Spec.Enum.maybe_enum_key_of_repr"
] | [] | false | false | false | false | false | let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e)) =
| p `parse_synth` (maybe_enum_key_of_repr e) | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.total_enum | val total_enum (key repr: eqtype) : Tot eqtype | val total_enum (key repr: eqtype) : Tot eqtype | let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } ) | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 41,
"end_line": 336,
"start_col": 0,
"start_line": 335
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | key: Prims.eqtype -> repr: Prims.eqtype -> Prims.eqtype | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.is_total_enum"
] | [] | false | false | false | true | false | let total_enum (key repr: eqtype) : Tot eqtype =
| (l: enum key repr {is_total_enum l}) | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.maybe_enum_key_of_total | val maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e) | val maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e) | let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 31,
"end_line": 423,
"start_col": 0,
"start_line": 416
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | e: LowParse.Spec.Enum.total_enum key repr -> k: LowParse.Spec.Enum.maybe_total_enum_key e
-> LowParse.Spec.Enum.maybe_enum_key e | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.total_enum",
"LowParse.Spec.Enum.maybe_total_enum_key",
"LowParse.Spec.Enum.Known",
"LowParse.Spec.Enum.unknown_enum_repr",
"LowParse.Spec.Enum.Unknown",
"LowParse.Spec.Enum.maybe_enum_key"
] | [] | false | false | false | false | false | let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e) =
| match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.maybe_enum_key_of_repr | val maybe_enum_key_of_repr (#key #repr: eqtype) (e: enum key repr) (r: repr)
: Tot (maybe_enum_key e) | val maybe_enum_key_of_repr (#key #repr: eqtype) (e: enum key repr) (r: repr)
: Tot (maybe_enum_key e) | let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 16,
"end_line": 260,
"start_col": 0,
"start_line": 253
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | e: LowParse.Spec.Enum.enum key repr -> r: repr -> LowParse.Spec.Enum.maybe_enum_key e | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.list_mem",
"LowParse.Spec.Enum.list_map",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.snd",
"LowParse.Spec.Enum.Known",
"LowParse.Spec.Enum.enum_key_of_repr",
"Prims.bool",
"LowParse.Spec.Enum.Unknown",
"LowParse.Spec.Enum.maybe_enum_key"
] | [] | false | false | false | false | false | let maybe_enum_key_of_repr (#key #repr: eqtype) (e: enum key repr) (r: repr)
: Tot (maybe_enum_key e) =
| if list_mem r (list_map snd e) then Known (enum_key_of_repr e r) else Unknown r | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.repr_of_maybe_total_enum_key | val repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr{maybe_total_enum_key_of_repr e r == k}) | val repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr{maybe_total_enum_key_of_repr e r == k}) | let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 23,
"end_line": 404,
"start_col": 0,
"start_line": 395
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | e: LowParse.Spec.Enum.total_enum key repr -> k: LowParse.Spec.Enum.maybe_total_enum_key e
-> r: repr{LowParse.Spec.Enum.maybe_total_enum_key_of_repr e r == k} | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.total_enum",
"LowParse.Spec.Enum.maybe_total_enum_key",
"LowParse.Spec.Enum.enum_repr_of_key",
"Prims.unit",
"LowParse.Spec.Enum.enum_key_of_repr_of_key",
"LowParse.Spec.Enum.unknown_enum_repr",
"Prims.eq2",
"LowParse.Spec.Enum.maybe_total_enum_key_of_repr"
] | [] | false | false | false | false | false | let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr{maybe_total_enum_key_of_repr e r == k}) =
| match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k';
enum_repr_of_key e k'
| TotalUnknown r -> r | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.maybe_total_enum_key_of_repr | val maybe_total_enum_key_of_repr (#key #repr: eqtype) (e: total_enum key repr) (r: repr)
: Tot (maybe_total_enum_key e) | val maybe_total_enum_key_of_repr (#key #repr: eqtype) (e: total_enum key repr) (r: repr)
: Tot (maybe_total_enum_key e) | let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 21,
"end_line": 385,
"start_col": 0,
"start_line": 378
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | e: LowParse.Spec.Enum.total_enum key repr -> r: repr -> LowParse.Spec.Enum.maybe_total_enum_key e | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.total_enum",
"LowParse.Spec.Enum.list_mem",
"LowParse.Spec.Enum.list_map",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.snd",
"LowParse.Spec.Enum.TotalKnown",
"LowParse.Spec.Enum.enum_key_of_repr",
"Prims.bool",
"LowParse.Spec.Enum.TotalUnknown",
"LowParse.Spec.Enum.maybe_total_enum_key"
] | [] | false | false | false | false | false | let maybe_total_enum_key_of_repr (#key #repr: eqtype) (e: total_enum key repr) (r: repr)
: Tot (maybe_total_enum_key e) =
| if list_mem r (list_map snd e) then TotalKnown (enum_key_of_repr e r) else TotalUnknown r | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.serialize_total_enum_key | val serialize_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l)) | val serialize_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l)) | let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) () | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 124,
"end_line": 372,
"start_col": 0,
"start_line": 364
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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: LowParse.Spec.Base.parser k repr ->
s: LowParse.Spec.Base.serializer p ->
l: LowParse.Spec.Enum.total_enum key repr
-> LowParse.Spec.Base.serializer (LowParse.Spec.Enum.parse_total_enum_key p l) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"Prims.eqtype",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.Enum.total_enum",
"LowParse.Spec.Combinators.serialize_synth",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Enum.parse_enum_key",
"LowParse.Spec.Enum.synth_total_enum_key",
"LowParse.Spec.Enum.serialize_enum_key",
"LowParse.Spec.Enum.synth_total_enum_key_recip",
"LowParse.Spec.Enum.parse_total_enum_key"
] | [] | false | false | false | false | false | let serialize_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l)) =
| serialize_synth (parse_enum_key p l)
(synth_total_enum_key l)
(serialize_enum_key p s l)
(synth_total_enum_key_recip l)
() | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.parse_maybe_enum_key_eq | val parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input ==
(match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None)) | val parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input ==
(match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None)) | let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 51,
"end_line": 281,
"start_col": 0,
"start_line": 270
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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: LowParse.Spec.Base.parser k repr ->
e: LowParse.Spec.Enum.enum key repr ->
input: LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Base.parse (LowParse.Spec.Enum.parse_maybe_enum_key p e) input ==
(match LowParse.Spec.Base.parse p input with
| FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ x consumed) ->
FStar.Pervasives.Native.Some (LowParse.Spec.Enum.maybe_enum_key_of_repr e x, consumed)
| _ -> FStar.Pervasives.Native.None)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"Prims.eqtype",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Enum.enum",
"LowParse.Bytes.bytes",
"LowParse.Spec.Combinators.parse_synth_eq",
"LowParse.Spec.Enum.maybe_enum_key",
"LowParse.Spec.Enum.maybe_enum_key_of_repr",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.Base.parse",
"LowParse.Spec.Enum.parse_maybe_enum_key",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.None",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input ==
(match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None)) =
| parse_synth_eq p (maybe_enum_key_of_repr e) input | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.feq | val feq (u v: Type) (eq: (v -> v -> GTot Type0)) (f1 f2: (u -> Tot v)) : GTot Type0 | val feq (u v: Type) (eq: (v -> v -> GTot Type0)) (f1 f2: (u -> Tot v)) : GTot Type0 | let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x)) | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 62,
"end_line": 529,
"start_col": 0,
"start_line": 524
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } ) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 |
u626: Type ->
v: Type ->
eq: (_: v -> _: v -> Prims.GTot Type0) ->
f1: (_: u626 -> v) ->
f2: (_: u626 -> v)
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.l_Forall"
] | [] | false | false | false | false | true | let feq (u v: Type) (eq: (v -> v -> GTot Type0)) (f1 f2: (u -> Tot v)) : GTot Type0 =
| (forall (x: u). {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x)) | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.enum_tail | val enum_tail (#key #repr: eqtype) (e: enum key repr) : Tot (enum key repr) | val enum_tail (#key #repr: eqtype) (e: enum key repr) : Tot (enum key repr) | let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 14,
"end_line": 612,
"start_col": 0,
"start_line": 608
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> [] | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | e: LowParse.Spec.Enum.enum key repr -> LowParse.Spec.Enum.enum key repr | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.enum_tail'"
] | [] | false | false | false | false | false | let enum_tail (#key #repr: eqtype) (e: enum key repr) : Tot (enum key repr) =
| enum_tail' e | false |
LowParse.Repr.fsti | LowParse.Repr.get_field | val get_field
(#k1: strong_parser_kind)
(#t1: _)
(#p1: LP.parser k1 t1)
(#k2: strong_parser_kind)
(#t2: Type)
(#p2: LP.parser k2 t2)
(f: field_accessor p1 p2)
: field_accessor_t f | val get_field
(#k1: strong_parser_kind)
(#t1: _)
(#p1: LP.parser k1 t1)
(#k2: strong_parser_kind)
(#t2: Type)
(#p2: LP.parser k2 t2)
(f: field_accessor p1 p2)
: field_accessor_t f | let get_field (#k1:strong_parser_kind) #t1 (#p1:LP.parser k1 t1)
(#k2: strong_parser_kind) (#t2:Type) (#p2:LP.parser k2 t2)
(f:field_accessor p1 p2)
: field_accessor_t f
= reveal_valid ();
fun p ->
[@inline_let] let FieldAccessor acc jump p2' = f in
let b = temp_slice_of_repr_ptr p in
let pos = acc b 0ul in
let pos_to = jump b pos in
let q = mk p2' b pos pos_to in
let h = get () in
assert (q.b `C.const_sub_buffer pos (pos_to - pos)` p.b);
assert (q `sub_ptr` p); //needed to trigger the sub_ptr_stable lemma
assert (is_stable_in_region p ==> is_stable_in_region q);
q | {
"file_name": "src/lowparse/LowParse.Repr.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 6,
"end_line": 661,
"start_col": 0,
"start_line": 646
} | (*
Copyright 2015--2019 INRIA and Microsoft Corporation
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.
Authors: T. Ramananandro, A. Rastogi, N. Swamy, A. Fromherz
*)
module LowParse.Repr
module LP = LowParse.Low.Base
module LS = LowParse.SLow.Base
module B = LowStar.Buffer
module HS = FStar.HyperStack
module C = LowStar.ConstBuffer
module U32 = FStar.UInt32
open FStar.Integers
open FStar.HyperStack.ST
module ST = FStar.HyperStack.ST
module I = LowStar.ImmutableBuffer
(* Summary:
A pointer-based representation type.
See
https://github.com/mitls/mitls-papers/wiki/The-Memory-Model-of-miTLS#pointer-based-transient-reprs
Calling it LowParse.Ptr since it should eventually move to everparse/src/lowparse
*)
/// `strong_parser_kind`: We restrict our attention to the
/// representation of types whose parsers have the strong-prefix
/// property.
let strong_parser_kind =
k:LP.parser_kind{
LP.(k.parser_kind_subkind == Some ParserStrong)
}
let preorder (c:C.const_buffer LP.byte) = C.qbuf_pre (C.as_qbuf c)
inline_for_extraction noextract
let slice_of_const_buffer (b:C.const_buffer LP.byte) (len:uint_32{U32.v len <= C.length b})
: LP.slice (preorder b) (preorder b)
=
LP.({
base = C.cast b;
len = len
})
let mut_p = LowStar.Buffer.trivial_preorder LP.byte
/// A slice is a const uint_8* and a length.
///
/// It is a layer around LP.slice, effectively guaranteeing that no
/// writes are performed via this pointer.
///
/// It allows us to uniformly represent `ptr t` backed by either
/// mutable or immutable arrays.
noeq
type const_slice =
| MkSlice:
base:C.const_buffer LP.byte ->
slice_len:uint_32 {
UInt32.v slice_len <= C.length base// /\
// slice_len <= LP.validator_max_length
} ->
const_slice
let to_slice (x:const_slice)
: Tot (LP.slice (preorder x.base) (preorder x.base))
= slice_of_const_buffer x.base x.slice_len
let of_slice (x:LP.slice mut_p mut_p)
: Tot const_slice
= let b = C.of_buffer x.LP.base in
let len = x.LP.len in
MkSlice b len
let live_slice (h:HS.mem) (c:const_slice) =
C.live h c.base
let slice_as_seq (h:HS.mem) (c:const_slice) =
Seq.slice (C.as_seq h c.base) 0 (U32.v c.slice_len)
(*** Pointer-based Representation types ***)
/// `meta t`: Each representation is associated with
/// specification metadata that records
///
/// -- the parser(s) that defines its wire format
/// -- the represented value
/// -- the bytes of its wire format
///
/// We retain both the value and its wire format for convenience.
///
/// An alternative would be to also retain here a serializer and then
/// compute the bytes when needed from the serializer. But that's a
/// bit heavy
[@erasable]
noeq
type meta (t:Type) = {
parser_kind: strong_parser_kind;
parser:LP.parser parser_kind t;
parser32:LS.parser32 parser;
v: t;
len: uint_32;
repr_bytes: Seq.lseq LP.byte (U32.v len);
meta_ok: squash (LowParse.Spec.Base.parse parser repr_bytes == Some (v, U32.v len))// /\
// 0ul < len /\
// len < LP.validator_max_length)
}
/// `repr_ptr t`: The main type of this module.
///
/// * The const pointer `b` refers to a representation of `t`
///
/// * The representation is described by erased the `meta` field
///
/// Temporary fields:
///
/// * At this stage, we also keep a real high-level value (vv). We
/// plan to gradually access instead its ghost (.meta.v) and
/// eventually get rid of it to lower implicit heap allocations.
///
/// * We also retain a concrete length field to facilitate using the
/// LowParse APIs for accessors and jumpers, which are oriented
/// towards using slices rather than pointers. As those APIs
/// change, we will remove the length field.
noeq
type repr_ptr (t:Type) =
| Ptr: b:C.const_buffer LP.byte ->
meta:meta t ->
vv:t ->
length:U32.t { U32.v meta.len == C.length b /\
meta.len == length /\
vv == meta.v } ->
repr_ptr t
let region_of #t (p:repr_ptr t) : GTot HS.rid = B.frameOf (C.cast p.b)
let value #t (p:repr_ptr t) : GTot t = p.meta.v
let repr_ptr_p (t:Type) (#k:strong_parser_kind) (parser:LP.parser k t) =
p:repr_ptr t{ p.meta.parser_kind == k /\ p.meta.parser == parser }
let slice_of_repr_ptr #t (p:repr_ptr t)
: GTot (LP.slice (preorder p.b) (preorder p.b))
= slice_of_const_buffer p.b p.meta.len
let sub_ptr (p2:repr_ptr 'a) (p1: repr_ptr 'b) =
exists pos len. Ptr?.b p2 `C.const_sub_buffer pos len` Ptr?.b p1
let intro_sub_ptr (x:repr_ptr 'a) (y:repr_ptr 'b) (from to:uint_32)
: Lemma
(requires
to >= from /\
Ptr?.b x `C.const_sub_buffer from (to - from)` Ptr?.b y)
(ensures
x `sub_ptr` y)
= ()
/// TEMPORARY: DO NOT USE THIS FUNCTION UNLESS YOU REALLY HAVE SOME
/// SPECIAL REASON FOR IT
///
/// It is meant to support migration towards an EverParse API that
/// will eventually provide accessors and jumpers for pointers rather
/// than slices
inline_for_extraction noextract
let temp_slice_of_repr_ptr #t (p:repr_ptr t)
: Tot (LP.slice (preorder p.b) (preorder p.b))
= slice_of_const_buffer p.b p.length
(*** Validity ***)
/// `valid' r h`:
/// We define validity in two stages:
///
/// First, we provide `valid'`, a transparent definition and then
/// turn it `abstract` by the `valid` predicate just below.
///
/// Validity encapsulates three related LowParse properties:notions:
///
/// 1. The underlying pointer contains a valid wire-format
/// (`valid_pos`)
///
/// 2. The ghost value associated with the `repr` is the
/// parsed value of the wire format.
///
/// 3. The bytes of the slice are indeed the representation of the
/// ghost value in wire format
unfold
let valid_slice (#t:Type) (#r #s:_) (slice:LP.slice r s) (meta:meta t) (h:HS.mem) =
LP.valid_content_pos meta.parser h slice 0ul meta.v meta.len /\
meta.repr_bytes == LP.bytes_of_slice_from_to h slice 0ul meta.len
unfold
let valid' (#t:Type) (p:repr_ptr t) (h:HS.mem) =
let slice = slice_of_const_buffer p.b p.meta.len in
valid_slice slice p.meta h
/// `valid`: abstract validity
val valid (#t:Type) (p:repr_ptr t) (h:HS.mem) : prop
/// `reveal_valid`:
/// An explicit lemma exposes the definition of `valid`
val reveal_valid (_:unit)
: Lemma (forall (t:Type) (p:repr_ptr t) (h:HS.mem).
{:pattern (valid #t p h)}
valid #t p h <==> valid' #t p h)
/// `fp r`: The memory footprint of a repr_ptr is the underlying pointer
let fp #t (p:repr_ptr t)
: GTot B.loc
= C.loc_buffer p.b
/// `frame_valid`:
/// A framing principle for `valid r h`
/// It is invariant under footprint-preserving heap updates
val frame_valid (#t:_) (p:repr_ptr t) (l:B.loc) (h0 h1:HS.mem)
: Lemma
(requires
valid p h0 /\
B.modifies l h0 h1 /\
B.loc_disjoint (fp p) l)
(ensures
valid p h1)
[SMTPat (valid p h1);
SMTPat (B.modifies l h0 h1)]
(*** Contructors ***)
/// `mk b from to p`:
/// Constructing a `repr_ptr` from a sub-slice
/// b.[from, to)
/// known to be valid for a given wire-format parser `p`
#set-options "--z3rlimit 20"
inline_for_extraction noextract
let mk_from_const_slice
(#k:strong_parser_kind) #t (#parser:LP.parser k t)
(parser32:LS.parser32 parser)
(b:const_slice)
(from to:uint_32)
: Stack (repr_ptr_p t parser)
(requires fun h ->
LP.valid_pos parser h (to_slice b) from to)
(ensures fun h0 p h1 ->
B.(modifies loc_none h0 h1) /\
valid p h1 /\
p.meta.v == LP.contents parser h1 (to_slice b) from /\
p.b `C.const_sub_buffer from (to - from)` b.base)
= reveal_valid ();
let h = get () in
let slice = to_slice b in
LP.contents_exact_eq parser h slice from to;
let meta :meta t = {
parser_kind = _;
parser = parser;
parser32 = parser32;
v = LP.contents parser h slice from;
len = to - from;
repr_bytes = LP.bytes_of_slice_from_to h slice from to;
meta_ok = ()
} in
let sub_b = C.sub b.base from (to - from) in
let value =
// Compute [.v]; this code will eventually disappear
let sub_b_bytes = FStar.Bytes.of_buffer (to - from) (C.cast sub_b) in
let Some (v, _) = parser32 sub_b_bytes in
v
in
let p = Ptr sub_b meta value (to - from) in
let h1 = get () in
let slice' = slice_of_const_buffer sub_b (to - from) in
LP.valid_facts p.meta.parser h1 slice from; //elim valid_pos slice
LP.valid_facts p.meta.parser h1 slice' 0ul; //intro valid_pos slice'
p
/// `mk b from to p`:
/// Constructing a `repr_ptr` from a LowParse slice
/// b.[from, to)
/// known to be valid for a given wire-format parser `p`
inline_for_extraction
noextract
let mk (#k:strong_parser_kind) #t (#parser:LP.parser k t)
(parser32:LS.parser32 parser)
#q
(slice:LP.slice (C.q_preorder q LP.byte) (C.q_preorder q LP.byte))
(from to:uint_32)
: Stack (repr_ptr_p t parser)
(requires fun h ->
LP.valid_pos parser h slice from to)
(ensures fun h0 p h1 ->
B.(modifies loc_none h0 h1) /\
valid p h1 /\
p.b `C.const_sub_buffer from (to - from)` (C.of_qbuf slice.LP.base) /\
p.meta.v == LP.contents parser h1 slice from)
= let c = MkSlice (C.of_qbuf slice.LP.base) slice.LP.len in
mk_from_const_slice parser32 c from to
/// A high-level constructor, taking a value instead of a slice.
///
/// Can we remove the `noextract` for the time being? Can we
/// `optimize` it so that vv is assigned x? It will take us a while to
/// lower all message writing.
inline_for_extraction
noextract
let mk_from_serialize
(#k:strong_parser_kind) #t (#parser:LP.parser k t) (#serializer: LP.serializer parser)
(parser32: LS.parser32 parser) (serializer32: LS.serializer32 serializer)
(size32: LS.size32 serializer)
(b:LP.slice mut_p mut_p)
(from:uint_32 { from <= b.LP.len })
(x: t)
: Stack (option (repr_ptr_p t parser))
(requires fun h ->
LP.live_slice h b)
(ensures fun h0 popt h1 ->
B.modifies (LP.loc_slice_from b from) h0 h1 /\
(match popt with
| None ->
(* not enough space in output slice *)
Seq.length (LP.serialize serializer x) > FStar.UInt32.v (b.LP.len - from)
| Some p ->
let size = size32 x in
valid p h1 /\
U32.v from + U32.v size <= U32.v b.LP.len /\
p.b == C.gsub (C.of_buffer b.LP.base) from size /\
p.meta.v == x))
= let size = size32 x in
let len = b.LP.len - from in
if len < size
then None
else begin
let bytes = serializer32 x in
let dst = B.sub b.LP.base from size in
(if size > 0ul then FStar.Bytes.store_bytes bytes dst);
let to = from + size in
let h = get () in
LP.serialize_valid_exact serializer h b x from to;
let r = mk parser32 b from to in
Some r
end
(*** Destructors ***)
/// Computes the length in bytes of the representation
/// Using a LowParse "jumper"
let length #t (p: repr_ptr t) (j:LP.jumper p.meta.parser)
: Stack U32.t
(requires fun h ->
valid p h)
(ensures fun h n h' ->
B.modifies B.loc_none h h' /\
n == p.meta.len)
= reveal_valid ();
let s = temp_slice_of_repr_ptr p in
(* TODO: Need to revise the type of jumpers to take a pointer as an argument, not a slice *)
j s 0ul
/// `to_bytes`: for intermediate purposes only, extract bytes from the repr
let to_bytes #t (p: repr_ptr t) (len:uint_32)
: Stack FStar.Bytes.bytes
(requires fun h ->
valid p h /\
len == p.meta.len
)
(ensures fun h x h' ->
B.modifies B.loc_none h h' /\
FStar.Bytes.reveal x == p.meta.repr_bytes /\
FStar.Bytes.len x == p.meta.len
)
= reveal_valid ();
FStar.Bytes.of_buffer len (C.cast p.b)
(*** Stable Representations ***)
(*
By copying a representation into an immutable buffer `i`,
we obtain a stable representation, which remains valid so long
as the `i` remains live.
We achieve this by relying on support for monotonic state provided
by Low*, as described in the POPL '18 paper "Recalling a Witness"
TODO: The feature also relies on an as yet unimplemented feature to
atomically allocate and initialize a buffer to a chosen
value. This will soon be added to the LowStar library.
*)
/// `valid_if_live`: A pure predicate on `r:repr_ptr t` that states that
/// so long as the underlying buffer is live in a given state `h`,
/// `p` is valid in that state
let valid_if_live #t (p:repr_ptr t) =
C.qbuf_qual (C.as_qbuf p.b) == C.IMMUTABLE /\
(let i : I.ibuffer LP.byte = C.as_mbuf p.b in
let m = p.meta in
i `I.value_is` Ghost.hide m.repr_bytes /\
(exists (h:HS.mem).{:pattern valid p h}
m.repr_bytes == B.as_seq h i /\
valid p h /\
(forall h'.
C.live h' p.b /\
B.as_seq h i `Seq.equal` B.as_seq h' i ==>
valid p h')))
/// `stable_repr_ptr t`: A representation that is valid if its buffer is
/// live
let stable_repr_ptr t= p:repr_ptr t { valid_if_live p }
/// `valid_if_live_intro` :
/// An internal lemma to introduce `valid_if_live`
// Note: the next proof is flaky and occasionally enters a triggering
// vortex with the notorious FStar.Seq.Properties.slice_slice
// Removing that from the context makes the proof instantaneous
#push-options "--max_ifuel 1 --initial_ifuel 1 \
--using_facts_from '* -FStar.Seq.Properties.slice_slice'"
let valid_if_live_intro #t (r:repr_ptr t) (h:HS.mem)
: Lemma
(requires (
C.qbuf_qual (C.as_qbuf r.b) == C.IMMUTABLE /\
valid r h /\
(let i : I.ibuffer LP.byte = C.as_mbuf r.b in
let m = r.meta in
B.as_seq h i == m.repr_bytes /\
i `I.value_is` Ghost.hide m.repr_bytes)))
(ensures
valid_if_live r)
= reveal_valid ();
let i : I.ibuffer LP.byte = C.as_mbuf r.b in
let aux (h':HS.mem)
: Lemma
(requires
C.live h' r.b /\
B.as_seq h i `Seq.equal` B.as_seq h' i)
(ensures
valid r h')
[SMTPat (valid r h')]
= let m = r.meta in
LP.valid_ext_intro m.parser h (slice_of_repr_ptr r) 0ul h' (slice_of_repr_ptr r) 0ul
in
()
let sub_ptr_stable (#t0 #t1:_) (r0:repr_ptr t0) (r1:repr_ptr t1) (h:HS.mem)
: Lemma
(requires
r0 `sub_ptr` r1 /\
valid_if_live r1 /\
valid r1 h /\
valid r0 h)
(ensures
valid_if_live r0 /\
(let b0 = C.cast r0.b in
let b1 = C.cast r1.b in
B.frameOf b0 == B.frameOf b1 /\
(B.region_lifetime_buf b1 ==>
B.region_lifetime_buf b0)))
[SMTPat (r0 `sub_ptr` r1);
SMTPat (valid_if_live r1);
SMTPat (valid r0 h)]
= reveal_valid ();
let b0 : I.ibuffer LP.byte = C.cast r0.b in
let b1 : I.ibuffer LP.byte = C.cast r1.b in
assert (I.value_is b1 (Ghost.hide r1.meta.repr_bytes));
assert (Seq.length r1.meta.repr_bytes == B.length b1);
let aux (i len:U32.t)
: Lemma
(requires
r0.b `C.const_sub_buffer i len` r1.b)
(ensures
I.value_is b0 (Ghost.hide r0.meta.repr_bytes))
[SMTPat (r0.b `C.const_sub_buffer i len` r1.b)]
= I.sub_ptr_value_is b0 b1 h i len r1.meta.repr_bytes
in
B.region_lifetime_sub #_ #_ #_ #(I.immutable_preorder _) b1 b0;
valid_if_live_intro r0 h
/// `recall_stable_repr_ptr` Main lemma: if the underlying buffer is live
/// then a stable repr_ptr is valid
let recall_stable_repr_ptr #t (r:stable_repr_ptr t)
: Stack unit
(requires fun h ->
C.live h r.b)
(ensures fun h0 _ h1 ->
h0 == h1 /\
valid r h1)
= reveal_valid ();
let h1 = get () in
let i = C.to_ibuffer r.b in
let aux (h:HS.mem)
: Lemma
(requires
valid r h /\
B.as_seq h i == B.as_seq h1 i)
(ensures
valid r h1)
[SMTPat (valid r h)]
= let m = r.meta in
LP.valid_ext_intro m.parser h (slice_of_repr_ptr r) 0ul h1 (slice_of_repr_ptr r) 0ul
in
let es =
let m = r.meta in
Ghost.hide m.repr_bytes
in
I.recall_value i es
let is_stable_in_region #t (p:repr_ptr t) =
let r = B.frameOf (C.cast p.b) in
valid_if_live p /\
B.frameOf (C.cast p.b) == r /\
B.region_lifetime_buf (C.cast p.b)
let stable_region_repr_ptr (r:ST.drgn) (t:Type) =
p:repr_ptr t {
is_stable_in_region p /\
B.frameOf (C.cast p.b) == ST.rid_of_drgn r
}
let recall_stable_region_repr_ptr #t (r:ST.drgn) (p:stable_region_repr_ptr r t)
: Stack unit
(requires fun h ->
HS.live_region h (ST.rid_of_drgn r))
(ensures fun h0 _ h1 ->
h0 == h1 /\
valid p h1)
= B.recall (C.cast p.b);
recall_stable_repr_ptr p
private
let ralloc_and_blit (r:ST.drgn) (src:C.const_buffer LP.byte) (len:U32.t)
: ST (b:C.const_buffer LP.byte)
(requires fun h0 ->
HS.live_region h0 (ST.rid_of_drgn r) /\
U32.v len == C.length src /\
C.live h0 src)
(ensures fun h0 b h1 ->
let c = C.as_qbuf b in
let s = Seq.slice (C.as_seq h0 src) 0 (U32.v len) in
let r = ST.rid_of_drgn r in
C.qbuf_qual c == C.IMMUTABLE /\
B.alloc_post_mem_common (C.to_ibuffer b) h0 h1 s /\
C.to_ibuffer b `I.value_is` s /\
B.region_lifetime_buf (C.cast b) /\
B.frameOf (C.cast b) == r)
= let src_buf = C.cast src in
assume (U32.v len > 0);
let b : I.ibuffer LP.byte = B.mmalloc_drgn_and_blit r src_buf 0ul len in
let h0 = get() in
B.witness_p b (I.seq_eq (Ghost.hide (Seq.slice (B.as_seq h0 src_buf) 0 (U32.v len))));
C.of_ibuffer b
/// `stash`: Main stateful operation
/// Copies a repr_ptr into a fresh stable repr_ptr in the given region
let stash (rgn:ST.drgn) #t (r:repr_ptr t) (len:uint_32{len == r.meta.len})
: ST (stable_region_repr_ptr rgn t)
(requires fun h ->
valid r h /\
HS.live_region h (ST.rid_of_drgn rgn))
(ensures fun h0 r' h1 ->
B.modifies B.loc_none h0 h1 /\
valid r' h1 /\
r.meta == r'.meta)
= reveal_valid ();
let buf' = ralloc_and_blit rgn r.b len in
let s = MkSlice buf' len in
let h = get () in
let _ =
let slice = slice_of_const_buffer r.b len in
let slice' = slice_of_const_buffer buf' len in
LP.valid_facts r.meta.parser h slice 0ul; //elim valid_pos slice
LP.valid_facts r.meta.parser h slice' 0ul //intro valid_pos slice'
in
let p = Ptr buf' r.meta r.vv r.length in
valid_if_live_intro p h;
p
(*** Accessing fields of ptrs ***)
/// Instances of field_accessor should be marked `unfold`
/// so that we get compact verification conditions for the lens conditions
/// and to inline the code for extraction
noeq inline_for_extraction
type field_accessor (#k1 #k2:strong_parser_kind)
(#t1 #t2:Type)
(p1 : LP.parser k1 t1)
(p2 : LP.parser k2 t2) =
| FieldAccessor :
(#cl: LP.clens t1 t2) ->
(#g: LP.gaccessor p1 p2 cl) ->
(acc:LP.accessor g) ->
(jump:LP.jumper p2) ->
(p2': LS.parser32 p2) ->
field_accessor p1 p2
unfold noextract
let field_accessor_comp (#k1 #k2 #k3:strong_parser_kind)
(#t1 #t2 #t3:Type)
(#p1 : LP.parser k1 t1)
(#p2 : LP.parser k2 t2)
(#p3 : LP.parser k3 t3)
(f12 : field_accessor p1 p2)
(f23 : field_accessor p2 p3)
: field_accessor p1 p3
=
[@inline_let] let FieldAccessor acc12 j2 p2' = f12 in
[@inline_let] let FieldAccessor acc23 j3 p3' = f23 in
[@inline_let] let acc13 = LP.accessor_compose acc12 acc23 () in
FieldAccessor acc13 j3 p3'
unfold noextract
let field_accessor_t
(#k1:strong_parser_kind) #t1 (#p1:LP.parser k1 t1)
(#k2: strong_parser_kind) (#t2:Type) (#p2:LP.parser k2 t2)
(f:field_accessor p1 p2)
= p:repr_ptr_p t1 p1 ->
Stack (repr_ptr_p t2 p2)
(requires fun h ->
valid p h /\
f.cl.LP.clens_cond p.meta.v)
(ensures fun h0 (q:repr_ptr_p t2 p2) h1 ->
f.cl.LP.clens_cond p.meta.v /\
B.modifies B.loc_none h0 h1 /\
valid q h1 /\
value q == f.cl.LP.clens_get (value p) /\
q `sub_ptr` p /\
region_of q == region_of p) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.ImmutableBuffer.fst.checked",
"LowStar.ConstBuffer.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.SLow.Base.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Integers.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Bytes.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Repr.fsti"
} | [
{
"abbrev": true,
"full_module": "LowStar.ImmutableBuffer",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.ConstBuffer",
"short_module": "C"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.SLow.Base",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "LowParse.Low.Base",
"short_module": "LP"
},
{
"abbrev": true,
"full_module": "LowStar.ImmutableBuffer",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.ConstBuffer",
"short_module": "C"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.SLow.Base",
"short_module": "LS"
},
{
"abbrev": true,
"full_module": "LowParse.Low.Base",
"short_module": "LP"
},
{
"abbrev": false,
"full_module": "LowParse",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse",
"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": 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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | f: LowParse.Repr.field_accessor p1 p2 -> LowParse.Repr.field_accessor_t f | Prims.Tot | [
"total"
] | [] | [
"LowParse.Repr.strong_parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Repr.field_accessor",
"LowParse.Repr.repr_ptr_p",
"LowParse.Low.Base.Spec.clens",
"LowParse.Low.Base.Spec.gaccessor",
"LowParse.Low.Base.accessor",
"LowParse.Low.Base.jumper",
"LowParse.SLow.Base.parser32",
"Prims.unit",
"Prims._assert",
"Prims.l_imp",
"LowParse.Repr.is_stable_in_region",
"LowParse.Repr.sub_ptr",
"LowStar.ConstBuffer.const_sub_buffer",
"LowParse.Bytes.byte",
"FStar.Integers.op_Subtraction",
"FStar.Integers.Unsigned",
"FStar.Integers.W32",
"LowParse.Repr.__proj__Ptr__item__b",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Repr.mk",
"LowStar.ConstBuffer.qbuf_qual",
"LowStar.ConstBuffer.as_qbuf",
"FStar.UInt32.t",
"LowParse.Repr.preorder",
"FStar.UInt32.__uint_to_t",
"LowParse.Slice.slice",
"LowParse.Repr.temp_slice_of_repr_ptr",
"LowParse.Repr.reveal_valid",
"LowParse.Repr.field_accessor_t"
] | [] | false | false | false | false | false | let get_field
(#k1: strong_parser_kind)
#t1
(#p1: LP.parser k1 t1)
(#k2: strong_parser_kind)
(#t2: Type)
(#p2: LP.parser k2 t2)
(f: field_accessor p1 p2)
: field_accessor_t f =
| reveal_valid ();
fun p ->
[@@ inline_let ]let FieldAccessor acc jump p2' = f in
let b = temp_slice_of_repr_ptr p in
let pos = acc b 0ul in
let pos_to = jump b pos in
let q = mk p2' b pos pos_to in
let h = get () in
assert (C.const_sub_buffer pos (pos_to - pos) q.b p.b);
assert (q `sub_ptr` p);
assert (is_stable_in_region p ==> is_stable_in_region q);
q | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.parse_total_enum_key | val parse_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key) | val parse_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key) | let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l) | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 59,
"end_line": 354,
"start_col": 0,
"start_line": 347
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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: LowParse.Spec.Base.parser k repr -> l: LowParse.Spec.Enum.total_enum key repr
-> LowParse.Spec.Base.parser (LowParse.Spec.Combinators.parse_filter_kind k) key | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"Prims.eqtype",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Enum.total_enum",
"LowParse.Spec.Combinators.parse_synth",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Enum.parse_enum_key",
"LowParse.Spec.Enum.synth_total_enum_key"
] | [] | false | false | false | false | false | let parse_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key) =
| (parse_enum_key p l) `parse_synth` (synth_total_enum_key l) | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.maybe_enum_key_of_repr_not_in | val maybe_enum_key_of_repr_not_in
(#key #repr: eqtype)
(e: enum key repr)
(l: list (key * repr))
(x: repr)
: GTot Type0 | val maybe_enum_key_of_repr_not_in
(#key #repr: eqtype)
(e: enum key repr)
(l: list (key * repr))
(x: repr)
: GTot Type0 | let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l))) | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 29,
"end_line": 792,
"start_col": 0,
"start_line": 791
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | e: LowParse.Spec.Enum.enum key repr -> l: Prims.list (key * repr) -> x: repr -> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.l_not",
"Prims.b2t",
"FStar.List.Tot.Base.mem",
"FStar.List.Tot.Base.map",
"FStar.Pervasives.Native.snd"
] | [] | false | false | false | false | true | let maybe_enum_key_of_repr_not_in
(#key #repr: eqtype)
(e: enum key repr)
(l: list (key * repr))
(x: repr)
: GTot Type0 =
| (~(L.mem x (L.map snd l))) | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.parse_maybe_total_enum_key | val parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e)) | val parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e)) | let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e) | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 50,
"end_line": 393,
"start_col": 0,
"start_line": 387
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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: LowParse.Spec.Base.parser k repr -> e: LowParse.Spec.Enum.total_enum key repr
-> LowParse.Spec.Base.parser k (LowParse.Spec.Enum.maybe_total_enum_key e) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"Prims.eqtype",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Enum.total_enum",
"LowParse.Spec.Combinators.parse_synth",
"LowParse.Spec.Enum.maybe_total_enum_key",
"LowParse.Spec.Enum.maybe_total_enum_key_of_repr"
] | [] | false | false | false | false | false | let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e)) =
| p `parse_synth` (maybe_total_enum_key_of_repr e) | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.total_of_maybe_enum_key | val total_of_maybe_enum_key (#key #repr: eqtype) (e: total_enum key repr) (k: maybe_enum_key e)
: Tot (maybe_total_enum_key e) | val total_of_maybe_enum_key (#key #repr: eqtype) (e: total_enum key repr) (k: maybe_enum_key e)
: Tot (maybe_total_enum_key e) | let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 31,
"end_line": 433,
"start_col": 0,
"start_line": 426
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | e: LowParse.Spec.Enum.total_enum key repr -> k: LowParse.Spec.Enum.maybe_enum_key e
-> LowParse.Spec.Enum.maybe_total_enum_key e | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.total_enum",
"LowParse.Spec.Enum.maybe_enum_key",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Enum.TotalKnown",
"LowParse.Spec.Enum.unknown_enum_repr",
"LowParse.Spec.Enum.TotalUnknown",
"LowParse.Spec.Enum.maybe_total_enum_key"
] | [] | false | false | false | false | false | let total_of_maybe_enum_key (#key #repr: eqtype) (e: total_enum key repr) (k: maybe_enum_key e)
: Tot (maybe_total_enum_key e) =
| match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.serialize_maybe_total_enum_key | val serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e)) | val serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e)) | let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) () | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 90,
"end_line": 413,
"start_col": 0,
"start_line": 406
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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: LowParse.Spec.Base.parser k repr ->
s: LowParse.Spec.Base.serializer p ->
e: LowParse.Spec.Enum.total_enum key repr
-> LowParse.Spec.Base.serializer (LowParse.Spec.Enum.parse_maybe_total_enum_key p e) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"Prims.eqtype",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.Enum.total_enum",
"LowParse.Spec.Combinators.serialize_synth",
"LowParse.Spec.Enum.maybe_total_enum_key",
"LowParse.Spec.Enum.maybe_total_enum_key_of_repr",
"LowParse.Spec.Enum.repr_of_maybe_total_enum_key",
"LowParse.Spec.Enum.parse_maybe_total_enum_key"
] | [] | false | false | false | false | false | let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e)) =
| serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) () | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.parse_maybe_total_enum_key_eq | val parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input ==
(parse ((parse_maybe_enum_key p e) `parse_synth` (total_of_maybe_enum_key e)) input)) | val parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input ==
(parse ((parse_maybe_enum_key p e) `parse_synth` (total_of_maybe_enum_key e)) input)) | let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 51,
"end_line": 453,
"start_col": 0,
"start_line": 443
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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: LowParse.Spec.Base.parser k repr ->
e: LowParse.Spec.Enum.total_enum key repr ->
input: LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Base.parse (LowParse.Spec.Enum.parse_maybe_total_enum_key p e) input ==
LowParse.Spec.Base.parse (LowParse.Spec.Combinators.parse_synth (LowParse.Spec.Enum.parse_maybe_enum_key
p
e)
(LowParse.Spec.Enum.total_of_maybe_enum_key e))
input) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"Prims.eqtype",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Enum.total_enum",
"LowParse.Bytes.bytes",
"LowParse.Spec.Combinators.parse_synth_eq",
"LowParse.Spec.Enum.maybe_enum_key",
"LowParse.Spec.Enum.maybe_enum_key_of_repr",
"Prims.unit",
"LowParse.Spec.Enum.maybe_total_enum_key",
"LowParse.Spec.Enum.parse_maybe_enum_key",
"LowParse.Spec.Enum.total_of_maybe_enum_key",
"LowParse.Spec.Enum.maybe_total_enum_key_of_repr",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.Base.parse",
"LowParse.Spec.Enum.parse_maybe_total_enum_key",
"LowParse.Spec.Combinators.parse_synth",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input ==
(parse ((parse_maybe_enum_key p e) `parse_synth` (total_of_maybe_enum_key e)) input)) =
| parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.r_reflexive_t_elim | val r_reflexive_t_elim (t: Type) (r: (t -> t -> GTot Type0)) (phi: r_reflexive_t t r)
: Lemma (r_reflexive_prop t r) | val r_reflexive_t_elim (t: Type) (r: (t -> t -> GTot Type0)) (phi: r_reflexive_t t r)
: Lemma (r_reflexive_prop t r) | let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 28,
"end_line": 479,
"start_col": 0,
"start_line": 473
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | t: Type -> r: (_: t -> _: t -> Prims.GTot Type0) -> phi: LowParse.Spec.Enum.r_reflexive_t t r
-> FStar.Pervasives.Lemma (ensures LowParse.Spec.Enum.r_reflexive_prop t r) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Spec.Enum.r_reflexive_t",
"FStar.Classical.forall_intro",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"LowParse.Spec.Enum.r_reflexive_prop",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let r_reflexive_t_elim (t: Type) (r: (t -> t -> GTot Type0)) (phi: r_reflexive_t t r)
: Lemma (r_reflexive_prop t r) =
| Classical.forall_intro phi | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.default_if | val default_if (t: Type) : Tot (if_combinator t (eq2 #t)) | val default_if (t: Type) : Tot (if_combinator t (eq2 #t)) | let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } ) | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 79,
"end_line": 522,
"start_col": 0,
"start_line": 513
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } ) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | t: Type -> LowParse.Spec.Enum.if_combinator t Prims.eq2 | Prims.Tot | [
"total"
] | [] | [
"Prims.bool",
"LowParse.Spec.Combinators.cond_true",
"LowParse.Spec.Combinators.cond_false",
"Prims.eq2",
"LowParse.Spec.Enum.if_combinator"
] | [] | false | false | false | true | false | let default_if (t: Type) : Tot (if_combinator t (eq2 #t)) =
| fun (cond: bool) (s_true: (cond_true cond -> Tot t)) (s_false: (cond_false cond -> Tot t)) ->
(if cond then s_true () else s_false ()) <: (y: t{y == (if cond then s_true () else s_false ())}) | false |
Steel.ST.Array.fsti | Steel.ST.Array.join | val join
(#opened: _)
(#elt: Type)
(#x1 #x2: Ghost.erased (Seq.seq elt))
(#p: P.perm)
(a1: array elt)
(a2: Ghost.erased (array elt))
: STAtomicBase (array elt)
false
opened
Unobservable
((pts_to a1 p x1) `star` (pts_to a2 p x2))
(fun res -> pts_to res p (x1 `Seq.append` x2))
(adjacent a1 a2)
(fun res -> merge_into a1 a2 res) | val join
(#opened: _)
(#elt: Type)
(#x1 #x2: Ghost.erased (Seq.seq elt))
(#p: P.perm)
(a1: array elt)
(a2: Ghost.erased (array elt))
: STAtomicBase (array elt)
false
opened
Unobservable
((pts_to a1 p x1) `star` (pts_to a2 p x2))
(fun res -> pts_to res p (x1 `Seq.append` x2))
(adjacent a1 a2)
(fun res -> merge_into a1 a2 res) | let join
(#opened: _)
(#elt: Type)
(#x1 #x2: Ghost.erased (Seq.seq elt))
(#p: P.perm)
(a1: array elt)
(a2: Ghost.erased (array elt))
: STAtomicBase (array elt) false opened Unobservable
(pts_to a1 p x1 `star` pts_to a2 p x2)
(fun res -> pts_to res p (x1 `Seq.append` x2))
(adjacent a1 a2)
(fun res -> merge_into a1 a2 res)
= let _ : squash (adjacent a1 a2) = () in
ghost_join a1 a2 ();
let res = merge a1 a2 in
rewrite
(pts_to (merge a1 (Ghost.hide (Ghost.reveal a2))) p (x1 `Seq.append` x2))
(pts_to res p (x1 `Seq.append` x2));
return res | {
"file_name": "lib/steel/Steel.ST.Array.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 12,
"end_line": 362,
"start_col": 0,
"start_line": 344
} | (*
Copyright 2020, 2021, 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law 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 Steel.ST.Array
/// C arrays of universe 0 elements, with selectors.
module P = Steel.FractionalPermission
module US = FStar.SizeT
module UP = FStar.PtrdiffT
open Steel.ST.Util
/// NOTE: This module is defined on top of Steel.HigherArray, so its
/// definitions are all meant to be inlined and benefit from the
/// latter module's primitive extraction. We seal it under an
/// interface to avoid unpleasantly leaking the lifting of values
/// of lower universes into the SMT context. Due to this interface,
/// cross-module inlining must be enabled using F*'s --cmi option.
/// An abstract type to represent a base array (whole allocation
/// unit), exposed for proof purposes only
[@@erasable]
val base_t (elt: Type0) : Tot Type0
val base_len (#elt: Type) (b: base_t elt) : GTot nat
/// An abstract type to represent a C pointer, as a base and an offset
/// into its base
inline_for_extraction
[@@noextract_to "krml"]
val ptr ([@@@unused] elt: Type0) : Type0
inline_for_extraction
[@@noextract_to "krml"]
val null_ptr (elt: Type0) : ptr elt
// TODO: turn into a stateful operation to avoid comparing dangling pointers
inline_for_extraction
[@@noextract_to "krml"]
val is_null_ptr (#elt: Type0) (p: ptr elt) : Pure bool
(requires True)
(ensures (fun res -> res == true <==> p == null_ptr elt))
val base (#elt: Type) (p: ptr elt) : Tot (base_t elt)
val offset (#elt: Type) (p: ptr elt) : Ghost nat (requires True) (ensures (fun offset -> offset <= base_len (base p)))
val ptr_base_offset_inj (#elt: Type) (p1 p2: ptr elt) : Lemma
(requires (
base p1 == base p2 /\
offset p1 == offset p2
))
(ensures (
p1 == p2
))
val base_len_null_ptr (elt: Type0) : Lemma
(base_len (base (null_ptr elt)) == 0)
[SMTPat (base_len (base (null_ptr elt)))]
/// A concrete type to represent a C array, as a C pointer and a ghost
/// array length. By virtue of the length being ghost, Karamel will
/// extract this type as just ptr, but to inline the definition of
/// this type, we use standard dependent pairs instead of a custom
/// record type.
inline_for_extraction
[@@noextract_to "krml"]
let array ([@@@strictly_positive] elt: Type0) : Tot Type0 =
(p: ptr elt & (length: Ghost.erased nat {offset p + length <= base_len (base p)}))
inline_for_extraction
[@@noextract_to "krml"]
let null (#a: Type0) : array a
= (| null_ptr a, Ghost.hide 0 |)
/// This will extract to "let p = a"
inline_for_extraction
[@@noextract_to "krml"]
let ptr_of
(#elt: Type)
(a: array elt)
: Tot (ptr elt)
= match a with // dfst is not marked inline_for_extraction, so we need to reimplement it
| (| p, _ |) -> p
inline_for_extraction
[@@noextract_to "krml"]
let is_null (#a: Type0) (p: array a) : Pure bool
(requires True)
(ensures (fun res -> res == true <==> p == null))
= is_null_ptr (ptr_of p)
/// Returns the length of the array. Usable for specification and proof purposes,
/// as modeled by the GTot effect
let length (#elt: Type) (a: array elt) : GTot nat =
dsnd a
val length_fits (#elt: Type) (a: array elt) : Lemma (US.fits (length a))
/// An abbreviation refining an array by its length
inline_for_extraction
[@@noextract_to "krml"]
let larray (t:Type) (n:nat) = a:array t{ length a = n }
/// The main representation predicate:
/// A Steel separation logic heap predicate to describe that an array
/// a points to some element sequence s with some permission p.
///
/// A big design decision in this library was whether the second index
/// of this predicate should be a [lseq t (length a)] or just a [seq t].
///
/// Making it an [lseq] forces every specification to be strongly
/// typed, in the sense that the logical representation of an array
/// has to be a sequence of the right length. This can be a little
/// cumbersome in specifications, particularly as the refinement appears
/// in some cases beneath the [erased] constructor.
///
/// So, we opted instead to let the index be just a [seq t], and
/// requiring length refinements on it in certain functions, only when
/// necessary.
val pts_to
(#elt: Type0) (a: array elt)
(p: P.perm)
([@@@ smt_fallback ] s: Seq.seq elt)
: Tot vprop
/// A stateful lemma to relate the size of an array with the size
/// of the element sequence it points to
/// This ghost function proves that an array always points to a
/// sequence of the appropriate length
val pts_to_length
(#opened: _)
(#elt: Type0)
(#p: P.perm)
(a: array elt)
(s: Seq.seq elt)
: STGhost unit opened
(pts_to a p s)
(fun _ -> pts_to a p s)
(True)
(fun _ -> Seq.length s == length a)
val pts_to_not_null
(#opened: _)
(#elt: Type0)
(#p: P.perm)
(a: array elt)
(s: Seq.seq elt)
: STGhost unit opened
(pts_to a p s)
(fun _ -> pts_to a p s)
(True)
(fun _ -> a =!= null)
/// An injectivity property, needed only to define a selector. Such a
/// selector can be only defined in universe 0, and universes are not
/// cumulative, so we need to define a separate module for arrays of
/// universe 0 elements with selectors, reusing definitions from this
/// interface, but we do not want to use `friend`.
val pts_to_inj
(#elt: Type0) (a: array elt)
(p1: P.perm)
(s1: Seq.seq elt)
(p2: P.perm)
(s2: Seq.seq elt)
(m: mem)
: Lemma
(requires (
interp (hp_of (pts_to a p1 s1)) m /\
interp (hp_of (pts_to a p2 s2)) m
))
(ensures (
s1 == s2
))
/// Allocating a new array of size n, where each cell is initialized
/// with value x. We define the non-selector version of this operation
/// (and others) with a _pt suffix in the name.
let is_full_array (#elt: Type) (a: array elt) : Tot prop =
length a == base_len (base (ptr_of a))
inline_for_extraction
[@@noextract_to "krml"]
val malloc
(#elt: Type)
(x: elt)
(n: US.t)
: ST (array elt)
emp
(fun a -> pts_to a P.full_perm (Seq.create (US.v n) x))
(True)
(fun a ->
length a == US.v n /\
is_full_array a
)
inline_for_extraction
[@@noextract_to "krml"]
let alloc #elt = malloc #elt
/// Freeing a full array.
inline_for_extraction
[@@ noextract_to "krml";
warn_on_use "Steel.Array.free_pt is currently unsound in the presence of zero-size subarrays, have you collected them all?"]
val free
(#elt: Type)
(a: array elt)
: ST unit
(exists_ (pts_to a P.full_perm))
(fun _ -> emp)
(
is_full_array a
)
(fun _ -> True)
/// Sharing and gathering permissions on an array. Those only
/// manipulate permissions, so they are nothing more than stateful
/// lemmas.
val share
(#opened: _)
(#elt: Type)
(#x: Seq.seq elt)
(a: array elt)
(p p1 p2: P.perm)
: STGhost unit opened
(pts_to a p x)
(fun _ -> pts_to a p1 x `star` pts_to a p2 x)
(p == p1 `P.sum_perm` p2)
(fun _ -> True)
val gather
(#opened: _)
(#elt: Type)
(a: array elt)
(#x1: Seq.seq elt) (p1: P.perm)
(#x2: Seq.seq elt) (p2: P.perm)
: STGhost unit opened
(pts_to a p1 x1 `star` pts_to a p2 x2)
(fun _ -> pts_to a (p1 `P.sum_perm` p2) x1)
(True)
(fun _ -> x1 == x2)
/// Reading the i-th element of an array a.
/// TODO: we should also provide an atomic version for small types.
inline_for_extraction
[@@noextract_to "krml"]
val index
(#t: Type) (#p: P.perm)
(a: array t)
(#s: Ghost.erased (Seq.seq t))
(i: US.t)
: ST t
(pts_to a p s)
(fun _ -> pts_to a p s)
(US.v i < length a \/ US.v i < Seq.length s)
(fun res -> Seq.length s == length a /\ US.v i < Seq.length s /\ res == Seq.index s (US.v i))
inline_for_extraction
[@@noextract_to "krml"]
let read #t #p = index #t #p
/// Writing the value v at the i-th element of an array a.
/// TODO: we should also provide an atomic version for small types.
inline_for_extraction
[@@noextract_to "krml"]
val upd
(#t: Type)
(a: array t)
(#s: Ghost.erased (Seq.seq t))
(i: US.t {US.v i < Seq.length s})
(v: t)
: STT unit
(pts_to a P.full_perm s)
(fun res -> pts_to a P.full_perm (Seq.upd s (US.v i) v))
inline_for_extraction
[@@noextract_to "krml"]
let write #t = upd #t
/// An array a1 is adjacent to an array a2 if and only if they have
/// the same base array and the end of a1 coincides with the beginning
/// of a2
let adjacent (#elt: Type) (a1 a2: array elt) : Tot prop =
base (ptr_of a1) == base (ptr_of a2) /\
offset (ptr_of a1) + (length a1) == offset (ptr_of a2)
/// If two arrays are adjacent, then we can compute their merge, with
/// their combined lengths. By virtue of the length being ghost,
/// Karamel will extract it as "let y = a1"
inline_for_extraction
[@@noextract_to "krml"]
let merge (#elt: Type) (a1: array elt) (a2: Ghost.erased (array elt))
: Pure (array elt)
(requires (adjacent a1 a2))
(ensures (fun y -> length y == length a1 + length a2))
= (| ptr_of a1, Ghost.hide (length a1 + length a2) |)
/// Adjacency and merging are associative.
let merge_assoc (#elt: Type) (a1 a2 a3: array elt) : Lemma
(requires (
(adjacent a1 a2 /\ adjacent a2 a3) \/
(adjacent a1 a2 /\ adjacent (merge a1 a2) a3) \/
(adjacent a2 a3 /\ adjacent a1 (merge a2 a3))
))
(ensures (
adjacent (merge a1 a2) a3 /\ adjacent a1 (merge a2 a3) /\
merge (merge a1 a2) a3 == merge a1 (merge a2 a3)
))
= ()
/// A shortcut to combine adjacency and merging
let merge_into (#elt: Type) (a1 a2 a: array elt) : Tot prop =
adjacent a1 a2 /\
merge a1 a2 == a
/// Spatial merging of two arrays, expressed in terms of `merge`.
val ghost_join
(#opened: _)
(#elt: Type)
(#x1 #x2: Seq.seq elt)
(#p: P.perm)
(a1 a2: array elt)
(h: squash (adjacent a1 a2))
: STGhostT unit opened
(pts_to a1 p x1 `star` pts_to a2 p x2)
(fun res -> pts_to (merge a1 a2) p (x1 `Seq.append` x2))
/// Spatial merging, combining the use of `merge` and the call to the
/// stateful lemma. Since the only operations are calls to stateful
/// lemmas and pure computations, the overall computation is atomic
/// and unobservable, so can be used anywhere in atomic contexts. By
/// virtue of the length being ghost, Karamel will extract this to
/// "let res = a1"
inline_for_extraction // this will extract to "let res = a1" | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.SizeT.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.PtrdiffT.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.ST.Array.fsti"
} | [
{
"abbrev": true,
"full_module": "Steel.ST.HigherArray",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "US"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.PtrdiffT",
"short_module": "UP"
},
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "US"
},
{
"abbrev": true,
"full_module": "Steel.FractionalPermission",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"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 | a1: Steel.ST.Array.array elt -> a2: FStar.Ghost.erased (Steel.ST.Array.array elt)
-> Steel.ST.Effect.Atomic.STAtomicBase (Steel.ST.Array.array elt) | Steel.ST.Effect.Atomic.STAtomicBase | [] | [] | [
"Steel.Memory.inames",
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"Steel.FractionalPermission.perm",
"Steel.ST.Array.array",
"Steel.ST.Util.return",
"Steel.ST.Array.pts_to",
"FStar.Seq.Base.append",
"FStar.Ghost.reveal",
"Steel.Effect.Common.vprop",
"Prims.unit",
"Steel.ST.Util.rewrite",
"Steel.ST.Array.merge",
"FStar.Ghost.hide",
"Steel.ST.Array.ghost_join",
"Prims.squash",
"Steel.ST.Array.adjacent",
"Steel.Effect.Common.Unobservable",
"Steel.Effect.Common.star",
"Prims.l_True",
"Steel.ST.Array.merge_into"
] | [] | false | true | false | false | false | let join
(#opened: _)
(#elt: Type)
(#x1 #x2: Ghost.erased (Seq.seq elt))
(#p: P.perm)
(a1: array elt)
(a2: Ghost.erased (array elt))
: STAtomicBase (array elt)
false
opened
Unobservable
((pts_to a1 p x1) `star` (pts_to a2 p x2))
(fun res -> pts_to res p (x1 `Seq.append` x2))
(adjacent a1 a2)
(fun res -> merge_into a1 a2 res) =
| let _:squash (adjacent a1 a2) = () in
ghost_join a1 a2 ();
let res = merge a1 a2 in
rewrite (pts_to (merge a1 (Ghost.hide (Ghost.reveal a2))) p (x1 `Seq.append` x2))
(pts_to res p (x1 `Seq.append` x2));
return res | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.r_transitive_t_elim | val r_transitive_t_elim (t: Type) (r: (t -> t -> GTot Type0)) (phi: r_transitive_t t r)
: Lemma (r_transitive_prop t r) | val r_transitive_t_elim (t: Type) (r: (t -> t -> GTot Type0)) (phi: r_transitive_t t r)
: Lemma (r_transitive_prop t r) | let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 30,
"end_line": 500,
"start_col": 0,
"start_line": 494
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | t: Type -> r: (_: t -> _: t -> Prims.GTot Type0) -> phi: LowParse.Spec.Enum.r_transitive_t t r
-> FStar.Pervasives.Lemma (ensures LowParse.Spec.Enum.r_transitive_prop t r) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Spec.Enum.r_transitive_t",
"FStar.Classical.forall_intro_3",
"Prims.l_imp",
"Prims.l_and",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"LowParse.Spec.Enum.r_transitive_prop",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let r_transitive_t_elim (t: Type) (r: (t -> t -> GTot Type0)) (phi: r_transitive_t t r)
: Lemma (r_transitive_prop t r) =
| Classical.forall_intro_3 phi | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.enum_tail' | val enum_tail' (#key #repr: eqtype) (e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures
(fun y ->
Cons? e ==>
(let _ :: y' = e in
y == y'))) | val enum_tail' (#key #repr: eqtype) (e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures
(fun y ->
Cons? e ==>
(let _ :: y' = e in
y == y'))) | let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> [] | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 36,
"end_line": 605,
"start_col": 0,
"start_line": 599
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } ) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | e: LowParse.Spec.Enum.enum key repr -> Prims.Pure (LowParse.Spec.Enum.enum key repr) | Prims.Pure | [] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"FStar.Pervasives.Native.tuple2",
"Prims.list",
"Prims.Nil",
"Prims.l_True",
"Prims.l_imp",
"Prims.b2t",
"Prims.uu___is_Cons",
"Prims.eq2",
"Prims.logical"
] | [] | false | false | false | false | false | let enum_tail' (#key #repr: eqtype) (e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures
(fun y ->
Cons? e ==>
(let _ :: y' = e in
y == y'))) =
| match e with
| _ :: y -> y
| _ -> [] | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.enum_destr_cons' | val enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit{Cons? e})
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e) | val enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit{Cons? e})
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e) | let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 23,
"end_line": 661,
"start_col": 0,
"start_line": 654
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 |
t: Type ->
key: Prims.eqtype ->
repr: Prims.eqtype ->
e: LowParse.Spec.Enum.enum key repr ->
u724: u726: Prims.unit{Cons? e} ->
g: LowParse.Spec.Enum.enum_destr_t t (LowParse.Spec.Enum.enum_tail e)
-> LowParse.Spec.Enum.enum_destr_t t e | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.unit",
"Prims.b2t",
"Prims.uu___is_Cons",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.enum_destr_t",
"LowParse.Spec.Enum.enum_tail",
"LowParse.Spec.Enum.enum_destr_cons"
] | [] | false | false | false | false | false | let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit{Cons? e})
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e) =
| enum_destr_cons t e g | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.feq_intro | val feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u -> Lemma ((f1 x) `eq` (f2 x))))
: Lemma (feq _ _ eq f1 f2) | val feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u -> Lemma ((f1 x) `eq` (f2 x))))
: Lemma (feq _ _ eq f1 f2) | let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 28,
"end_line": 549,
"start_col": 0,
"start_line": 543
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 |
u662: Type ->
v: Type ->
eq: (_: v -> _: v -> Prims.GTot Type0) ->
f1: (_: u662 -> v) ->
f2: (_: u662 -> v) ->
phi: (x: u662 -> FStar.Pervasives.Lemma (ensures eq (f1 x) (f2 x)))
-> FStar.Pervasives.Lemma (ensures LowParse.Spec.Enum.feq u662 v eq f1 f2) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"FStar.Classical.forall_intro",
"LowParse.Spec.Enum.feq"
] | [] | false | false | true | false | false | let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u -> Lemma ((f1 x) `eq` (f2 x))))
: Lemma (feq _ _ eq f1 f2) =
| Classical.forall_intro phi | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.enum_destr_cons_nil | val enum_destr_cons_nil (t: Type) (#key #repr: eqtype) (e: enum key repr)
: Pure (enum_destr_t t e) (requires (Cons? e /\ Nil? (enum_tail' e))) (ensures (fun _ -> True)) | val enum_destr_cons_nil (t: Type) (#key #repr: eqtype) (e: enum key repr)
: Pure (enum_destr_t t e) (requires (Cons? e /\ Nil? (enum_tail' e))) (ensures (fun _ -> True)) | let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 5,
"end_line": 679,
"start_col": 0,
"start_line": 664
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | t: Type -> e: LowParse.Spec.Enum.enum key repr -> Prims.Pure (LowParse.Spec.Enum.enum_destr_t t e) | Prims.Pure | [] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.if_combinator",
"LowParse.Spec.Enum.r_reflexive_t",
"LowParse.Spec.Enum.r_transitive_t",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.enum_key",
"Prims.unit",
"LowParse.Spec.Enum.r_reflexive_t_elim",
"LowParse.Spec.Enum.enum_destr_t",
"Prims.l_and",
"Prims.b2t",
"Prims.uu___is_Cons",
"Prims.uu___is_Nil",
"LowParse.Spec.Enum.enum_tail'",
"Prims.l_True"
] | [] | false | false | false | false | false | let enum_destr_cons_nil (t: Type) (#key #repr: eqtype) (e: enum key repr)
: Pure (enum_destr_t t e) (requires (Cons? e /\ Nil? (enum_tail' e))) (ensures (fun _ -> True)) =
| fun
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
->
[@@ inline_let ]let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e': list (key * repr) {e' == e}) ->
match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((f k) <: (y: t{eq y (f x)})))) e | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.fif | val fif (u v: Type) (eq: (v -> v -> GTot Type0)) (ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq)) | val fif (u v: Type) (eq: (v -> v -> GTot Type0)) (ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq)) | let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x) | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 29,
"end_line": 582,
"start_col": 0,
"start_line": 573
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 |
u678: Type ->
v: Type ->
eq: (_: v -> _: v -> Prims.GTot Type0) ->
ifc: LowParse.Spec.Enum.if_combinator v eq
-> LowParse.Spec.Enum.if_combinator (_: u678 -> v) (LowParse.Spec.Enum.feq u678 v eq) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Enum.if_combinator",
"Prims.bool",
"LowParse.Spec.Combinators.cond_true",
"LowParse.Spec.Combinators.cond_false",
"LowParse.Spec.Enum.feq"
] | [] | false | false | false | false | false | let fif (u v: Type) (eq: (v -> v -> GTot Type0)) (ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq)) =
| fun
(cond: bool)
(s_true: (cond_true cond -> u -> Tot v))
(s_false: (cond_false cond -> u -> Tot v))
(x: u)
->
ifc cond (fun h -> s_true () x) (fun h -> s_false () x) | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.enum_destr_cons | val enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e) (requires (Cons? e)) (ensures (fun _ -> True)) | val enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e) (requires (Cons? e)) (ensures (fun _ -> True)) | let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 5,
"end_line": 651,
"start_col": 0,
"start_line": 615
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 |
t: Type ->
e: LowParse.Spec.Enum.enum key repr ->
g: LowParse.Spec.Enum.enum_destr_t t (LowParse.Spec.Enum.enum_tail' e)
-> Prims.Pure (LowParse.Spec.Enum.enum_destr_t t e) | Prims.Pure | [] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.enum_destr_t",
"LowParse.Spec.Enum.enum_tail'",
"LowParse.Spec.Enum.if_combinator",
"LowParse.Spec.Enum.r_reflexive_t",
"LowParse.Spec.Enum.r_transitive_t",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.enum_key",
"Prims.op_Equality",
"LowParse.Spec.Combinators.cond_true",
"LowParse.Spec.Combinators.cond_false",
"Prims.unit",
"LowParse.Spec.Enum.r_transitive_t_elim",
"LowParse.Spec.Enum.r_reflexive_t_elim",
"Prims.b2t",
"Prims.uu___is_Cons",
"Prims.l_True"
] | [] | false | false | false | false | false | let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e) (requires (Cons? e)) (ensures (fun _ -> True)) =
| fun
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
->
[@@ inline_let ]let _ = r_reflexive_t_elim _ _ eq_refl in
[@@ inline_let ]let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e': list (key * repr) {e' == e}) ->
match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) ->
(([@@ inline_let ]let f':(enum_key (enum_tail' e) -> Tot t) =
(fun (x': enum_key (enum_tail' e)) ->
[@@ inline_let ]let x_:enum_key e = (x' <: key) in
f x_)
in
[@@ inline_let ]let y:t =
ift ((k <: key) = x)
(fun h -> f k)
(fun h ->
[@@ inline_let ]let x':enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y)
<:
(y: t{eq y (f x)})))) e | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.destr_maybe_total_enum_repr | val destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: (x: maybe_total_enum_key e -> Tot t))
(x: repr)
: Tot (y: t{eq y (f (maybe_total_enum_key_of_repr e x))}) | val destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: (x: maybe_total_enum_key e -> Tot t))
(x: repr)
: Tot (y: t{eq y (f (maybe_total_enum_key_of_repr e x))}) | let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 76,
"end_line": 868,
"start_col": 0,
"start_line": 856
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 |
e: LowParse.Spec.Enum.total_enum key repr ->
destr: LowParse.Spec.Enum.maybe_enum_destr_t t e ->
eq: (_: t -> _: t -> Prims.GTot Type0) ->
ift: LowParse.Spec.Enum.if_combinator t eq ->
eq_refl: LowParse.Spec.Enum.r_reflexive_t t eq ->
eq_trans: LowParse.Spec.Enum.r_transitive_t t eq ->
f: (x: LowParse.Spec.Enum.maybe_total_enum_key e -> t) ->
x: repr
-> y: t{eq y (f (LowParse.Spec.Enum.maybe_total_enum_key_of_repr e x))} | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.total_enum",
"LowParse.Spec.Enum.maybe_enum_destr_t",
"LowParse.Spec.Enum.if_combinator",
"LowParse.Spec.Enum.r_reflexive_t",
"LowParse.Spec.Enum.r_transitive_t",
"LowParse.Spec.Enum.maybe_total_enum_key",
"LowParse.Spec.Enum.maybe_enum_key",
"LowParse.Spec.Enum.total_of_maybe_enum_key",
"LowParse.Spec.Enum.maybe_total_enum_key_of_repr"
] | [] | false | false | false | false | false | let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: (x: maybe_total_enum_key e -> Tot t))
(x: repr)
: Tot (y: t{eq y (f (maybe_total_enum_key_of_repr e x))}) =
| destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.list_append_rev_cons | val list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t)
: Lemma (L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2) | val list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t)
: Lemma (L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2) | let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2 | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 34,
"end_line": 806,
"start_col": 0,
"start_line": 803
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | l1: Prims.list t -> x: t -> l2: Prims.list t
-> FStar.Pervasives.Lemma
(ensures FStar.List.Tot.Base.rev l1 @ x :: l2 == FStar.List.Tot.Base.rev (x :: l1) @ l2) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"FStar.List.Tot.Properties.append_assoc",
"FStar.List.Tot.Base.rev",
"Prims.Cons",
"Prims.Nil",
"Prims.unit",
"LowParse.Spec.Enum.list_rev_cons",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.List.Tot.Base.append",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t)
: Lemma (L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2) =
| list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2 | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.dep_enum_destr_cons_nil | val dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v) | val dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v) | let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } )) | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 42,
"end_line": 786,
"start_col": 0,
"start_line": 765
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } )) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 |
e: LowParse.Spec.Enum.enum key repr ->
u773: Prims.squash (Cons? e /\ Nil? (LowParse.Spec.Enum.enum_tail e)) ->
v: (_: LowParse.Spec.Enum.enum_key e -> Type)
-> LowParse.Spec.Enum.dep_enum_destr e v | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.squash",
"Prims.l_and",
"Prims.b2t",
"Prims.uu___is_Cons",
"FStar.Pervasives.Native.tuple2",
"Prims.uu___is_Nil",
"LowParse.Spec.Enum.enum_tail",
"LowParse.Spec.Enum.enum_key",
"Prims.list",
"LowParse.Spec.Enum.if_combinator",
"LowParse.Spec.Enum.r_reflexive_t",
"LowParse.Spec.Enum.r_transitive_t",
"Prims.unit",
"LowParse.Spec.Enum.r_transitive_t_elim",
"LowParse.Spec.Enum.r_reflexive_t_elim",
"LowParse.Spec.Enum.dep_enum_destr"
] | [] | false | false | false | false | false | let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v) =
| match e with
| (k, _) :: _ ->
fun
(v_eq: (k: enum_key e -> v k -> v k -> GTot Type0))
(v_if: (k: enum_key e -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: (k: enum_key e -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: (k: enum_key e -> Tot (r_transitive_t _ (v_eq k))))
(f: (k: enum_key e -> Tot (v k)))
(k': enum_key e)
->
[@@ inline_let ]let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@@ inline_let ]let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@@ inline_let ]let y:v k' = f k in
(y <: (y: v k' {v_eq k' y (f k')})) | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.mk_maybe_enum_destr | val mk_maybe_enum_destr (t: Type) (#key #repr: eqtype) (e: enum key repr)
: Tot (maybe_enum_destr_t t e) | val mk_maybe_enum_destr (t: Type) (#key #repr: eqtype) (e: enum key repr)
: Tot (maybe_enum_destr_t t e) | let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ()) | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 65,
"end_line": 1003,
"start_col": 0,
"start_line": 998
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | t: Type -> e: LowParse.Spec.Enum.enum key repr -> LowParse.Spec.Enum.maybe_enum_destr_t t e | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.maybe_enum_destr_t_intro",
"LowParse.Spec.Enum.mk_maybe_enum_destr'",
"Prims.Nil",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.maybe_enum_destr_t"
] | [] | false | false | false | false | false | let mk_maybe_enum_destr (t: Type) (#key #repr: eqtype) (e: enum key repr)
: Tot (maybe_enum_destr_t t e) =
| maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ()) | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.list_rev_cons | val list_rev_cons (#t: Type) (a: t) (q: list t) : Lemma (L.rev (a :: q) == (L.rev q) `L.append` [a]) | val list_rev_cons (#t: Type) (a: t) (q: list t) : Lemma (L.rev (a :: q) == (L.rev q) `L.append` [a]) | let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 14,
"end_line": 801,
"start_col": 0,
"start_line": 794
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | a: t -> q: Prims.list t
-> FStar.Pervasives.Lemma
(ensures FStar.List.Tot.Base.rev (a :: q) == FStar.List.Tot.Base.rev q @ [a]) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"FStar.List.Tot.Properties.rev_rev'",
"Prims.unit",
"Prims.Cons",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.List.Tot.Base.rev",
"FStar.List.Tot.Base.append",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let list_rev_cons (#t: Type) (a: t) (q: list t) : Lemma (L.rev (a :: q) == (L.rev q) `L.append` [a]) =
| L.rev_rev' (a :: q);
L.rev_rev' q | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.list_hd | val list_hd : l: Prims.list t {Cons? l} -> t | let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 15,
"end_line": 897,
"start_col": 0,
"start_line": 893
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm] | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | l: Prims.list t {Cons? l} -> t | Prims.Tot | [
"total"
] | [] | [
"Prims.list",
"Prims.b2t",
"Prims.uu___is_Cons"
] | [] | false | false | false | false | false | let list_hd (#t: Type) (l: list t {Cons? l}) =
| match l with | a :: _ -> a | false |
|
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.list_rev_map | val list_rev_map (#t1 #t2: Type) (f: (t1 -> Tot t2)) (l: list t1)
: Lemma (L.rev (L.map f l) == L.map f (L.rev l)) | val list_rev_map (#t1 #t2: Type) (f: (t1 -> Tot t2)) (l: list t1)
: Lemma (L.rev (L.map f l) == L.map f (L.rev l)) | let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a] | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 32,
"end_line": 957,
"start_col": 0,
"start_line": 945
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | f: (_: t1 -> t2) -> l: Prims.list t1
-> FStar.Pervasives.Lemma
(ensures
FStar.List.Tot.Base.rev (FStar.List.Tot.Base.map f l) ==
FStar.List.Tot.Base.map f (FStar.List.Tot.Base.rev l)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"FStar.List.Tot.Properties.map_append",
"FStar.List.Tot.Base.rev",
"Prims.Cons",
"Prims.Nil",
"Prims.unit",
"LowParse.Spec.Enum.list_rev_map",
"LowParse.Spec.Enum.list_rev_cons",
"FStar.List.Tot.Base.map",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec list_rev_map (#t1 #t2: Type) (f: (t1 -> Tot t2)) (l: list t1)
: Lemma (L.rev (L.map f l) == L.map f (L.rev l)) =
| match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a] | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.mk_dep_maybe_enum_destr' | val mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1) (decreases l2) | val mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1) (decreases l2) | let rec mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
(decreases l2)
= match l2 with
| [] -> dep_maybe_enum_destr_nil e v l1 l2 u1
| _ -> dep_maybe_enum_destr_cons e v l1 l2 u1 (mk_dep_maybe_enum_destr' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))) | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 162,
"end_line": 1138,
"start_col": 0,
"start_line": 1127
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d
inline_for_extraction
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
inline_for_extraction
let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } )
-> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
//NS: y is linear in the continuation after erasure
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@inline_let]
let _ = v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x)) in
y
) <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } )) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 |
e: LowParse.Spec.Enum.enum key repr ->
v: (_: LowParse.Spec.Enum.maybe_enum_key e -> Type) ->
l1: Prims.list (key * repr) ->
l2: Prims.list (key * repr) ->
u1: Prims.squash (e == FStar.List.Tot.Base.rev l1 @ l2)
-> Prims.Tot (LowParse.Spec.Enum.dep_maybe_enum_destr_t' e v l1 l2 u1) | Prims.Tot | [
"total",
""
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.maybe_enum_key",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.squash",
"Prims.eq2",
"FStar.List.Tot.Base.append",
"FStar.List.Tot.Base.rev",
"LowParse.Spec.Enum.dep_maybe_enum_destr_nil",
"LowParse.Spec.Enum.dep_maybe_enum_destr_cons",
"LowParse.Spec.Enum.mk_dep_maybe_enum_destr'",
"Prims.Cons",
"LowParse.Spec.Enum.list_hd",
"LowParse.Spec.Enum.list_tl",
"LowParse.Spec.Enum.list_append_rev_cons",
"LowParse.Spec.Enum.dep_maybe_enum_destr_t'"
] | [
"recursion"
] | false | false | false | false | false | let rec mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1) (decreases l2) =
| match l2 with
| [] -> dep_maybe_enum_destr_nil e v l1 l2 u1
| _ ->
dep_maybe_enum_destr_cons e
v
l1
l2
u1
(mk_dep_maybe_enum_destr' e
v
(list_hd l2 :: l1)
(list_tl l2)
(list_append_rev_cons l1 (list_hd l2) (list_tl l2))) | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.enum_destr_cons_nil' | val enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit{Cons? e})
(u2: unit{Nil? (enum_tail e)})
: Tot (enum_destr_t t e) | val enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit{Cons? e})
(u2: unit{Nil? (enum_tail e)})
: Tot (enum_destr_t t e) | let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 25,
"end_line": 689,
"start_col": 0,
"start_line": 682
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 |
t: Type ->
key: Prims.eqtype ->
repr: Prims.eqtype ->
e: LowParse.Spec.Enum.enum key repr ->
u1: Prims.unit{Cons? e} ->
u2: Prims.unit{Nil? (LowParse.Spec.Enum.enum_tail e)}
-> LowParse.Spec.Enum.enum_destr_t t e | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.unit",
"Prims.b2t",
"Prims.uu___is_Cons",
"FStar.Pervasives.Native.tuple2",
"Prims.uu___is_Nil",
"LowParse.Spec.Enum.enum_tail",
"LowParse.Spec.Enum.enum_destr_cons_nil",
"LowParse.Spec.Enum.enum_destr_t"
] | [] | false | false | false | false | false | let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit{Cons? e})
(u2: unit{Nil? (enum_tail e)})
: Tot (enum_destr_t t e) =
| enum_destr_cons_nil t e | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.assoc_append_flip_l_intro | val assoc_append_flip_l_intro (#key #repr: eqtype) (l1 l2: list (key * repr)) (y: repr) (x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x)) | val assoc_append_flip_l_intro (#key #repr: eqtype) (l1 l2: list (key * repr)) (y: repr) (x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x)) | let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 38,
"end_line": 823,
"start_col": 0,
"start_line": 808
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | l1: Prims.list (key * repr) -> l2: Prims.list (key * repr) -> y: repr -> x: key
-> FStar.Pervasives.Lemma
(requires
FStar.List.Tot.Base.noRepeats (FStar.List.Tot.Base.map FStar.Pervasives.Native.snd (l1 @ l2)
) /\
FStar.List.Tot.Base.assoc y (FStar.List.Tot.Base.map LowParse.Spec.Enum.flip l2) ==
FStar.Pervasives.Native.Some x)
(ensures
FStar.List.Tot.Base.assoc y (FStar.List.Tot.Base.map LowParse.Spec.Enum.flip (l1 @ l2)) ==
FStar.Pervasives.Native.Some x) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.eqtype",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.assoc_append_flip_l_intro",
"Prims.unit",
"FStar.List.Tot.Properties.noRepeats_append_elim",
"FStar.List.Tot.Base.map",
"FStar.Pervasives.Native.snd",
"FStar.List.Tot.Properties.map_append",
"LowParse.Spec.Enum.map_fst_flip",
"FStar.List.Tot.Properties.assoc_mem",
"LowParse.Spec.Enum.flip",
"Prims.l_and",
"Prims.b2t",
"FStar.List.Tot.Base.noRepeats",
"FStar.List.Tot.Base.append",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.List.Tot.Base.assoc",
"FStar.Pervasives.Native.Some",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec assoc_append_flip_l_intro (#key #repr: eqtype) (l1 l2: list (key * repr)) (y: repr) (x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x)) =
| match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.list_forallp_mem | val list_forallp_mem (#t: eqtype) (p: (t -> GTot Type0)) (l: list t)
: Lemma (list_forallp p l <==> (forall x. L.mem x l ==> p x)) | val list_forallp_mem (#t: eqtype) (p: (t -> GTot Type0)) (l: list t)
: Lemma (list_forallp p l <==> (forall x. L.mem x l ==> p x)) | let rec list_forallp_mem (#t: eqtype) (p: t -> GTot Type0) (l: list t) : Lemma
(list_forallp p l <==> (forall x . L.mem x l ==> p x))
= match l with
| [] -> ()
| _ :: q -> list_forallp_mem p q | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 34,
"end_line": 1158,
"start_col": 0,
"start_line": 1154
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d
inline_for_extraction
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
inline_for_extraction
let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } )
-> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
//NS: y is linear in the continuation after erasure
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@inline_let]
let _ = v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x)) in
y
) <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
(decreases l2)
= match l2 with
| [] -> dep_maybe_enum_destr_nil e v l1 l2 u1
| _ -> dep_maybe_enum_destr_cons e v l1 l2 u1 (mk_dep_maybe_enum_destr' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2)))
[@Norm]
let mk_dep_maybe_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
= dep_maybe_enum_destr_t_intro e v (mk_dep_maybe_enum_destr' e v [] e ())
(* Eliminators and destructors for verification purposes *)
let rec list_forallp (#t: Type) (p: t -> GTot Type0) (l: list t) : GTot Type0 =
match l with
| [] -> True
| a :: q -> p a /\ list_forallp p q | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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: (_: t -> Prims.GTot Type0) -> l: Prims.list t
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Enum.list_forallp p l <==> (forall (x: t). FStar.List.Tot.Base.mem x l ==> p x)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.eqtype",
"Prims.list",
"LowParse.Spec.Enum.list_forallp_mem",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_iff",
"LowParse.Spec.Enum.list_forallp",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.b2t",
"FStar.List.Tot.Base.mem",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec list_forallp_mem (#t: eqtype) (p: (t -> GTot Type0)) (l: list t)
: Lemma (list_forallp p l <==> (forall x. L.mem x l ==> p x)) =
| match l with
| [] -> ()
| _ :: q -> list_forallp_mem p q | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.maybe_enum_destr_t_intro | val maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e) | val maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e) | let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 877,
"start_col": 0,
"start_line": 871
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 |
t: Type ->
e: LowParse.Spec.Enum.enum key repr ->
f: LowParse.Spec.Enum.maybe_enum_destr_t' t e [] e ()
-> LowParse.Spec.Enum.maybe_enum_destr_t t e | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.maybe_enum_destr_t'",
"Prims.Nil",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.maybe_enum_destr_t"
] | [] | false | false | false | false | false | let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e) =
| f | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.mk_dep_maybe_enum_destr | val mk_dep_maybe_enum_destr : e: LowParse.Spec.Enum.enum key repr -> v: (_: LowParse.Spec.Enum.maybe_enum_key e -> Type)
-> LowParse.Spec.Enum.dep_maybe_enum_destr_t e v | let mk_dep_maybe_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
= dep_maybe_enum_destr_t_intro e v (mk_dep_maybe_enum_destr' e v [] e ()) | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 73,
"end_line": 1145,
"start_col": 0,
"start_line": 1141
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d
inline_for_extraction
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
inline_for_extraction
let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } )
-> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
//NS: y is linear in the continuation after erasure
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@inline_let]
let _ = v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x)) in
y
) <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
(decreases l2)
= match l2 with
| [] -> dep_maybe_enum_destr_nil e v l1 l2 u1
| _ -> dep_maybe_enum_destr_cons e v l1 l2 u1 (mk_dep_maybe_enum_destr' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | e: LowParse.Spec.Enum.enum key repr -> v: (_: LowParse.Spec.Enum.maybe_enum_key e -> Type)
-> LowParse.Spec.Enum.dep_maybe_enum_destr_t e v | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.maybe_enum_key",
"LowParse.Spec.Enum.dep_maybe_enum_destr_t_intro",
"LowParse.Spec.Enum.mk_dep_maybe_enum_destr'",
"Prims.Nil",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.dep_maybe_enum_destr_t"
] | [] | false | false | false | false | false | let mk_dep_maybe_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
=
| dep_maybe_enum_destr_t_intro e v (mk_dep_maybe_enum_destr' e v [] e ()) | false |
|
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.dep_maybe_enum_destr_cons | val dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g:
(dep_maybe_enum_destr_t' e
v
(list_hd l2 :: l1)
(list_tl l2)
(list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1) | val dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g:
(dep_maybe_enum_destr_t' e
v
(list_hd l2 :: l1)
(list_tl l2)
(list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1) | let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } )) | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 120,
"end_line": 1095,
"start_col": 0,
"start_line": 1047
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 |
e: LowParse.Spec.Enum.enum key repr ->
v: (_: LowParse.Spec.Enum.maybe_enum_key e -> Type) ->
l1: Prims.list (key * repr) ->
l2: Prims.list (key * repr) ->
u1: Prims.squash (Cons? l2 /\ e == FStar.List.Tot.Base.rev l1 @ l2) ->
g:
LowParse.Spec.Enum.dep_maybe_enum_destr_t' e
v
(LowParse.Spec.Enum.list_hd l2 :: l1)
(LowParse.Spec.Enum.list_tl l2)
(LowParse.Spec.Enum.list_append_rev_cons l1
(LowParse.Spec.Enum.list_hd l2)
(LowParse.Spec.Enum.list_tl l2))
-> LowParse.Spec.Enum.dep_maybe_enum_destr_t' e v l1 l2 u1 | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.maybe_enum_key",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.squash",
"Prims.l_and",
"Prims.b2t",
"Prims.uu___is_Cons",
"Prims.eq2",
"FStar.List.Tot.Base.append",
"FStar.List.Tot.Base.rev",
"LowParse.Spec.Enum.dep_maybe_enum_destr_t'",
"Prims.Cons",
"LowParse.Spec.Enum.list_hd",
"LowParse.Spec.Enum.list_tl",
"LowParse.Spec.Enum.list_append_rev_cons",
"LowParse.Spec.Enum.if_combinator",
"LowParse.Spec.Enum.r_reflexive_t",
"LowParse.Spec.Enum.r_transitive_t",
"LowParse.Spec.Enum.maybe_enum_key_of_repr_not_in",
"LowParse.Spec.Enum.maybe_enum_key_of_repr",
"Prims.op_Equality",
"Prims.bool",
"LowParse.Spec.Combinators.cond_true",
"LowParse.Spec.Enum.Known",
"LowParse.Spec.Combinators.cond_false",
"Prims.unit",
"LowParse.Spec.Enum.assoc_append_flip_l_intro",
"FStar.List.Tot.Properties.map_append",
"FStar.Pervasives.Native.snd",
"FStar.List.Tot.Properties.append_mem",
"FStar.List.Tot.Base.map",
"FStar.List.Tot.Base.mem",
"FStar.Pervasives.Native.fst"
] | [] | false | false | false | false | false | let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g:
(dep_maybe_enum_destr_t' e
v
(list_hd l2 :: l1)
(list_tl l2)
(list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1) =
| fun
(v_eq: (k: maybe_enum_key e -> v k -> v k -> GTot Type0))
(v_if: (k: maybe_enum_key e -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: (k: maybe_enum_key e -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: (k: maybe_enum_key e -> Tot (r_transitive_t _ (v_eq k))))
(f: (k: maybe_enum_key e -> Tot (v k)))
->
match list_hd l2 with
| k, r ->
[@@ inline_let ]let _:squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@@ inline_let ]let _:squash (maybe_enum_key_of_repr e r == Known k) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr{maybe_enum_key_of_repr_not_in e l1 x}) ->
[@@ inline_let ]let y:v (maybe_enum_key_of_repr e x) =
v_if (maybe_enum_key_of_repr e x)
(x = r)
(fun h -> f (Known k))
(fun h -> g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@@ inline_let ]let _:squash (v_eq (maybe_enum_key_of_repr e x)
y
(f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else
v_eq_trans (maybe_enum_key_of_repr e x)
y
(g v_eq v_if v_eq_refl v_eq_trans f x)
(f (maybe_enum_key_of_repr e x))
in
(y
<:
(y:
v (maybe_enum_key_of_repr e x)
{v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))})) | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.list_tl | val list_tl : l: Prims.list t {Cons? l} -> Prims.list t | let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 15,
"end_line": 905,
"start_col": 0,
"start_line": 901
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm] | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 | l: Prims.list t {Cons? l} -> Prims.list t | Prims.Tot | [
"total"
] | [] | [
"Prims.list",
"Prims.b2t",
"Prims.uu___is_Cons"
] | [] | false | false | false | false | false | let list_tl (#t: Type) (l: list t {Cons? l}) =
| match l with | _ :: q -> q | false |
|
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.dep_maybe_enum_destr_t_intro | val dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v) | val dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v) | let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 1044,
"start_col": 0,
"start_line": 1038
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } ) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 |
e: LowParse.Spec.Enum.enum key repr ->
v: (_: LowParse.Spec.Enum.maybe_enum_key e -> Type) ->
d: LowParse.Spec.Enum.dep_maybe_enum_destr_t' e v [] e ()
-> LowParse.Spec.Enum.dep_maybe_enum_destr_t e v | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.maybe_enum_key",
"LowParse.Spec.Enum.dep_maybe_enum_destr_t'",
"Prims.Nil",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.dep_maybe_enum_destr_t"
] | [] | false | false | false | false | false | let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v) =
| d | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.mk_maybe_enum_destr' | val mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u: squash (e == (L.rev l1) `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u) (decreases l2) | val mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u: squash (e == (L.rev l1) `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u) (decreases l2) | let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u) | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 98,
"end_line": 995,
"start_col": 0,
"start_line": 981
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 |
t: Type ->
e: LowParse.Spec.Enum.enum key repr ->
l1: Prims.list (key * repr) ->
l2: Prims.list (key * repr) ->
u954: Prims.squash (e == FStar.List.Tot.Base.rev l1 @ l2)
-> Prims.Tot (LowParse.Spec.Enum.maybe_enum_destr_t' t e l1 l2 u954) | Prims.Tot | [
"total",
""
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.squash",
"Prims.eq2",
"FStar.List.Tot.Base.append",
"FStar.List.Tot.Base.rev",
"LowParse.Spec.Enum.maybe_enum_destr_nil",
"LowParse.Spec.Enum.maybe_enum_destr_cons",
"LowParse.Spec.Enum.mk_maybe_enum_destr'",
"Prims.Cons",
"LowParse.Spec.Enum.list_hd",
"LowParse.Spec.Enum.list_tl",
"Prims.unit",
"LowParse.Spec.Enum.list_append_rev_cons",
"LowParse.Spec.Enum.maybe_enum_destr_t'"
] | [
"recursion"
] | false | false | false | false | false | let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u: squash (e == (L.rev l1) `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u) (decreases l2) =
| match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@@ inline_let ]let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u) | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.maybe_enum_key_of_repr'_t_cons_nil | val maybe_enum_key_of_repr'_t_cons_nil (#key #repr: eqtype) (e: enum key repr)
: Pure (maybe_enum_key_of_repr'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True)) | val maybe_enum_key_of_repr'_t_cons_nil (#key #repr: eqtype) (e: enum key repr)
: Pure (maybe_enum_key_of_repr'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True)) | let maybe_enum_key_of_repr'_t_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
: Pure (maybe_enum_key_of_repr'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| [(k, r)] ->
(fun x -> ((
if r = x
then Known k
else Unknown x
) <: (k: maybe_enum_key e { k == maybe_enum_key_of_repr e x } ))))
e | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 5,
"end_line": 1303,
"start_col": 0,
"start_line": 1290
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d
inline_for_extraction
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
inline_for_extraction
let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } )
-> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
//NS: y is linear in the continuation after erasure
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@inline_let]
let _ = v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x)) in
y
) <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
(decreases l2)
= match l2 with
| [] -> dep_maybe_enum_destr_nil e v l1 l2 u1
| _ -> dep_maybe_enum_destr_cons e v l1 l2 u1 (mk_dep_maybe_enum_destr' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2)))
[@Norm]
let mk_dep_maybe_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
= dep_maybe_enum_destr_t_intro e v (mk_dep_maybe_enum_destr' e v [] e ())
(* Eliminators and destructors for verification purposes *)
let rec list_forallp (#t: Type) (p: t -> GTot Type0) (l: list t) : GTot Type0 =
match l with
| [] -> True
| a :: q -> p a /\ list_forallp p q
let rec list_forallp_mem (#t: eqtype) (p: t -> GTot Type0) (l: list t) : Lemma
(list_forallp p l <==> (forall x . L.mem x l ==> p x))
= match l with
| [] -> ()
| _ :: q -> list_forallp_mem p q
inline_for_extraction
let destruct_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> Tot Type)
(f_known: (
(x: key) ->
(u: squash (list_mem x (list_map fst e))) ->
Tot (f (Known x))
))
(f_unknown: (
(x: value) ->
(u: squash (list_mem x (list_map snd e) == false)) ->
Tot (f (Unknown x))
))
(x: maybe_enum_key e)
: Tot (f x)
= match x with
| Known x' -> f_known x' ()
| Unknown x' -> f_unknown x' ()
let forall_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> GTot Type0)
(f_known: squash (list_forallp (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e)))
(f_unknown: (
(x: value) ->
Tot (squash (list_mem x (list_map snd e) == false ==> f (Unknown x)))
))
: Tot (squash (forall (x: maybe_enum_key e) . f x))
= let g
(x: maybe_enum_key e)
: Lemma
(f x)
= let u : squash (f x) =
destruct_maybe_enum_key
e
(fun y -> squash (f y))
(fun x' u -> list_forallp_mem (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e))
(fun x' u -> f_unknown x') x
in
assert (f x)
in
Classical.forall_intro g
(* Converting enum keys to their representation, using combinators *)
let enum_repr_of_key'_t
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (x: enum_key e) ->
Tot (r: enum_repr e { r == enum_repr_of_key e x } )
inline_for_extraction
let enum_repr_of_key_cons
(#key #repr: eqtype)
(e: enum key repr)
(f : enum_repr_of_key'_t (enum_tail' e))
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, r) :: _ ->
(fun (x: enum_key e) -> (
if k = x
then (r <: repr)
else (f (x <: key) <: repr)
) <: (r: enum_repr e { enum_repr_of_key e x == r } )))
e
inline_for_extraction
let enum_repr_of_key_cons'
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(f : enum_repr_of_key'_t (enum_tail' e))
: Tot (enum_repr_of_key'_t e)
= enum_repr_of_key_cons e f
inline_for_extraction
let enum_repr_of_key_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| [(k, r)] ->
(fun (x: enum_key e) ->
(r <: (r: enum_repr e { enum_repr_of_key e x == r } ))))
e
inline_for_extraction
let enum_repr_of_key_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail' e) } )
: Tot (enum_repr_of_key'_t e)
= enum_repr_of_key_cons_nil e
let enum_repr_of_key_append_cons
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key & repr))
(kr: (key & repr))
(l2: list (key & repr))
: Lemma
(requires (e == l1 `L.append` (kr :: l2)))
(ensures (list_mem (fst kr) (list_map fst e) /\ enum_repr_of_key e (fst kr) == snd kr /\ list_mem (snd kr) (list_map snd e) /\ enum_key_of_repr e (snd kr) == fst kr))
= L.map_append fst l1 (kr :: l2);
L.noRepeats_append_elim (L.map fst l1) (L.map fst (kr :: l2));
L.assoc_mem (fst kr) l1;
L.assoc_mem (fst kr) e;
L.assoc_append_elim_l (fst kr) l1 (kr :: l2);
enum_key_of_repr_of_key e (fst kr)
let maybe_enum_key_of_repr'_t
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (x: repr) ->
Tot (k: maybe_enum_key e { k == maybe_enum_key_of_repr e x } )
#push-options "--z3rlimit 32" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | e: LowParse.Spec.Enum.enum key repr -> Prims.Pure (LowParse.Spec.Enum.maybe_enum_key_of_repr'_t e) | Prims.Pure | [] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.op_Equality",
"LowParse.Spec.Enum.Known",
"Prims.bool",
"LowParse.Spec.Enum.Unknown",
"LowParse.Spec.Enum.maybe_enum_key",
"Prims.eq2",
"LowParse.Spec.Enum.maybe_enum_key_of_repr",
"LowParse.Spec.Enum.maybe_enum_key_of_repr'_t",
"Prims.l_and",
"Prims.b2t",
"Prims.uu___is_Cons",
"FStar.Pervasives.Native.tuple2",
"Prims.uu___is_Nil",
"LowParse.Spec.Enum.enum_tail'",
"Prims.l_True"
] | [] | false | false | false | false | false | let maybe_enum_key_of_repr'_t_cons_nil (#key #repr: eqtype) (e: enum key repr)
: Pure (maybe_enum_key_of_repr'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True)) =
| (fun (e': list (key * repr) {e' == e}) ->
match e' with
| [k, r] ->
(fun x ->
((if r = x then Known k else Unknown x)
<:
(k: maybe_enum_key e {k == maybe_enum_key_of_repr e x})))) e | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.maybe_enum_key_of_repr'_t_cons' | val maybe_enum_key_of_repr'_t_cons'
(key repr: eqtype)
(e: enum key repr)
(u: unit{Cons? e})
(g: maybe_enum_key_of_repr'_t (enum_tail' e))
: Tot (maybe_enum_key_of_repr'_t e) | val maybe_enum_key_of_repr'_t_cons'
(key repr: eqtype)
(e: enum key repr)
(u: unit{Cons? e})
(g: maybe_enum_key_of_repr'_t (enum_tail' e))
: Tot (maybe_enum_key_of_repr'_t e) | let maybe_enum_key_of_repr'_t_cons'
(key repr: eqtype)
(e: enum key repr )
(u: unit { Cons? e } )
(g : maybe_enum_key_of_repr'_t (enum_tail' e))
: Tot (maybe_enum_key_of_repr'_t e)
= maybe_enum_key_of_repr'_t_cons e g | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 36,
"end_line": 1342,
"start_col": 0,
"start_line": 1336
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d
inline_for_extraction
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
inline_for_extraction
let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } )
-> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
//NS: y is linear in the continuation after erasure
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@inline_let]
let _ = v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x)) in
y
) <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
(decreases l2)
= match l2 with
| [] -> dep_maybe_enum_destr_nil e v l1 l2 u1
| _ -> dep_maybe_enum_destr_cons e v l1 l2 u1 (mk_dep_maybe_enum_destr' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2)))
[@Norm]
let mk_dep_maybe_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
= dep_maybe_enum_destr_t_intro e v (mk_dep_maybe_enum_destr' e v [] e ())
(* Eliminators and destructors for verification purposes *)
let rec list_forallp (#t: Type) (p: t -> GTot Type0) (l: list t) : GTot Type0 =
match l with
| [] -> True
| a :: q -> p a /\ list_forallp p q
let rec list_forallp_mem (#t: eqtype) (p: t -> GTot Type0) (l: list t) : Lemma
(list_forallp p l <==> (forall x . L.mem x l ==> p x))
= match l with
| [] -> ()
| _ :: q -> list_forallp_mem p q
inline_for_extraction
let destruct_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> Tot Type)
(f_known: (
(x: key) ->
(u: squash (list_mem x (list_map fst e))) ->
Tot (f (Known x))
))
(f_unknown: (
(x: value) ->
(u: squash (list_mem x (list_map snd e) == false)) ->
Tot (f (Unknown x))
))
(x: maybe_enum_key e)
: Tot (f x)
= match x with
| Known x' -> f_known x' ()
| Unknown x' -> f_unknown x' ()
let forall_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> GTot Type0)
(f_known: squash (list_forallp (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e)))
(f_unknown: (
(x: value) ->
Tot (squash (list_mem x (list_map snd e) == false ==> f (Unknown x)))
))
: Tot (squash (forall (x: maybe_enum_key e) . f x))
= let g
(x: maybe_enum_key e)
: Lemma
(f x)
= let u : squash (f x) =
destruct_maybe_enum_key
e
(fun y -> squash (f y))
(fun x' u -> list_forallp_mem (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e))
(fun x' u -> f_unknown x') x
in
assert (f x)
in
Classical.forall_intro g
(* Converting enum keys to their representation, using combinators *)
let enum_repr_of_key'_t
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (x: enum_key e) ->
Tot (r: enum_repr e { r == enum_repr_of_key e x } )
inline_for_extraction
let enum_repr_of_key_cons
(#key #repr: eqtype)
(e: enum key repr)
(f : enum_repr_of_key'_t (enum_tail' e))
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, r) :: _ ->
(fun (x: enum_key e) -> (
if k = x
then (r <: repr)
else (f (x <: key) <: repr)
) <: (r: enum_repr e { enum_repr_of_key e x == r } )))
e
inline_for_extraction
let enum_repr_of_key_cons'
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(f : enum_repr_of_key'_t (enum_tail' e))
: Tot (enum_repr_of_key'_t e)
= enum_repr_of_key_cons e f
inline_for_extraction
let enum_repr_of_key_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| [(k, r)] ->
(fun (x: enum_key e) ->
(r <: (r: enum_repr e { enum_repr_of_key e x == r } ))))
e
inline_for_extraction
let enum_repr_of_key_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail' e) } )
: Tot (enum_repr_of_key'_t e)
= enum_repr_of_key_cons_nil e
let enum_repr_of_key_append_cons
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key & repr))
(kr: (key & repr))
(l2: list (key & repr))
: Lemma
(requires (e == l1 `L.append` (kr :: l2)))
(ensures (list_mem (fst kr) (list_map fst e) /\ enum_repr_of_key e (fst kr) == snd kr /\ list_mem (snd kr) (list_map snd e) /\ enum_key_of_repr e (snd kr) == fst kr))
= L.map_append fst l1 (kr :: l2);
L.noRepeats_append_elim (L.map fst l1) (L.map fst (kr :: l2));
L.assoc_mem (fst kr) l1;
L.assoc_mem (fst kr) e;
L.assoc_append_elim_l (fst kr) l1 (kr :: l2);
enum_key_of_repr_of_key e (fst kr)
let maybe_enum_key_of_repr'_t
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (x: repr) ->
Tot (k: maybe_enum_key e { k == maybe_enum_key_of_repr e x } )
#push-options "--z3rlimit 32"
inline_for_extraction
let maybe_enum_key_of_repr'_t_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
: Pure (maybe_enum_key_of_repr'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| [(k, r)] ->
(fun x -> ((
if r = x
then Known k
else Unknown x
) <: (k: maybe_enum_key e { k == maybe_enum_key_of_repr e x } ))))
e
inline_for_extraction
let maybe_enum_key_of_repr'_t_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail' e) } )
: Tot (maybe_enum_key_of_repr'_t e)
= maybe_enum_key_of_repr'_t_cons_nil e
inline_for_extraction
let maybe_enum_key_of_repr'_t_cons
(#key #repr: eqtype)
(e: enum key repr )
(g : maybe_enum_key_of_repr'_t (enum_tail' e))
: Pure (maybe_enum_key_of_repr'_t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, r) :: _ ->
(fun x -> ((
if r = x
then Known k
else
let y : maybe_enum_key (enum_tail' e) = g x in
match y with
| Known k' -> Known (k' <: key)
| Unknown x' -> Unknown x
) <: (k: maybe_enum_key e { k == maybe_enum_key_of_repr e x } ))))
e | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
key: Prims.eqtype ->
repr: Prims.eqtype ->
e: LowParse.Spec.Enum.enum key repr ->
u1179: u1181: Prims.unit{Cons? e} ->
g: LowParse.Spec.Enum.maybe_enum_key_of_repr'_t (LowParse.Spec.Enum.enum_tail' e)
-> LowParse.Spec.Enum.maybe_enum_key_of_repr'_t e | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.unit",
"Prims.b2t",
"Prims.uu___is_Cons",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.maybe_enum_key_of_repr'_t",
"LowParse.Spec.Enum.enum_tail'",
"LowParse.Spec.Enum.maybe_enum_key_of_repr'_t_cons"
] | [] | false | false | false | false | false | let maybe_enum_key_of_repr'_t_cons'
(key repr: eqtype)
(e: enum key repr)
(u: unit{Cons? e})
(g: maybe_enum_key_of_repr'_t (enum_tail' e))
: Tot (maybe_enum_key_of_repr'_t e) =
| maybe_enum_key_of_repr'_t_cons e g | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.maybe_enum_destr_nil | val maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1) | val maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1) | let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )) | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 57,
"end_line": 978,
"start_col": 0,
"start_line": 960
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a] | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 |
t: Type ->
e: LowParse.Spec.Enum.enum key repr ->
l1: Prims.list (key * repr) ->
l2: Prims.list (key * repr) ->
u1: Prims.squash (Nil? l2 /\ e == FStar.List.Tot.Base.rev l1 @ [])
-> LowParse.Spec.Enum.maybe_enum_destr_t' t e l1 l2 u1 | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.squash",
"Prims.l_and",
"Prims.b2t",
"Prims.uu___is_Nil",
"Prims.eq2",
"FStar.List.Tot.Base.append",
"FStar.List.Tot.Base.rev",
"Prims.Nil",
"LowParse.Spec.Enum.if_combinator",
"LowParse.Spec.Enum.r_reflexive_t",
"LowParse.Spec.Enum.r_transitive_t",
"LowParse.Spec.Enum.maybe_enum_key",
"LowParse.Spec.Enum.maybe_enum_key_of_repr_not_in",
"LowParse.Spec.Enum.Unknown",
"Prims.unit",
"FStar.List.Tot.Properties.rev_mem",
"FStar.List.Tot.Base.map",
"FStar.Pervasives.Native.snd",
"LowParse.Spec.Enum.list_rev_map",
"FStar.List.Tot.Properties.append_l_nil",
"LowParse.Spec.Enum.maybe_enum_key_of_repr",
"LowParse.Spec.Enum.r_transitive_t_elim",
"LowParse.Spec.Enum.r_reflexive_t_elim",
"LowParse.Spec.Enum.maybe_enum_destr_t'"
] | [] | false | false | false | false | false | let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1) =
| fun
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: (maybe_enum_key e -> Tot t))
->
[@@ inline_let ]let _ = r_reflexive_t_elim _ _ eq_refl in
[@@ inline_let ]let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr{maybe_enum_key_of_repr_not_in e l1 x}) ->
((L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x))
<:
(y: t{eq y (f (maybe_enum_key_of_repr e x))})) | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.dep_maybe_enum_destr_nil | val dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1) | val dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1) | let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } )
-> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
//NS: y is linear in the continuation after erasure
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@inline_let]
let _ = v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x)) in
y
) <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } )) | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 117,
"end_line": 1124,
"start_col": 0,
"start_line": 1098
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d
inline_for_extraction
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } )) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 |
e: LowParse.Spec.Enum.enum key repr ->
v: (_: LowParse.Spec.Enum.maybe_enum_key e -> Type) ->
l1: Prims.list (key * repr) ->
l2: Prims.list (key * repr) ->
u1: Prims.squash (Nil? l2 /\ e == FStar.List.Tot.Base.rev l1 @ [])
-> LowParse.Spec.Enum.dep_maybe_enum_destr_t' e v l1 l2 u1 | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.maybe_enum_key",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.squash",
"Prims.l_and",
"Prims.b2t",
"Prims.uu___is_Nil",
"Prims.eq2",
"FStar.List.Tot.Base.append",
"FStar.List.Tot.Base.rev",
"Prims.Nil",
"LowParse.Spec.Enum.if_combinator",
"LowParse.Spec.Enum.r_reflexive_t",
"LowParse.Spec.Enum.r_transitive_t",
"LowParse.Spec.Enum.maybe_enum_key_of_repr_not_in",
"Prims.unit",
"LowParse.Spec.Enum.maybe_enum_key_of_repr",
"LowParse.Spec.Enum.Unknown",
"Prims._assert",
"FStar.List.Tot.Properties.rev_mem",
"FStar.List.Tot.Base.map",
"FStar.Pervasives.Native.snd",
"LowParse.Spec.Enum.list_rev_map",
"FStar.List.Tot.Properties.append_l_nil",
"LowParse.Spec.Enum.dep_maybe_enum_destr_t'"
] | [] | false | false | false | false | false | let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1) =
| fun
(v_eq: (k: maybe_enum_key e -> v k -> v k -> GTot Type0))
(v_if: (k: maybe_enum_key e -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: (k: maybe_enum_key e -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: (k: maybe_enum_key e -> Tot (r_transitive_t _ (v_eq k))))
(f: (k: maybe_enum_key e -> Tot (v k)))
(x: repr{maybe_enum_key_of_repr_not_in e l1 x})
->
((L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
[@@ inline_let ]let y:v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@@ inline_let ]let _ =
v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x))
in
y)
<:
(y:
v (maybe_enum_key_of_repr e x)
{v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))})) | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.list_forallp | val list_forallp (#t: Type) (p: (t -> GTot Type0)) (l: list t) : GTot Type0 | val list_forallp (#t: Type) (p: (t -> GTot Type0)) (l: list t) : GTot Type0 | let rec list_forallp (#t: Type) (p: t -> GTot Type0) (l: list t) : GTot Type0 =
match l with
| [] -> True
| a :: q -> p a /\ list_forallp p q | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 37,
"end_line": 1152,
"start_col": 0,
"start_line": 1149
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d
inline_for_extraction
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
inline_for_extraction
let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } )
-> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
//NS: y is linear in the continuation after erasure
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@inline_let]
let _ = v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x)) in
y
) <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
(decreases l2)
= match l2 with
| [] -> dep_maybe_enum_destr_nil e v l1 l2 u1
| _ -> dep_maybe_enum_destr_cons e v l1 l2 u1 (mk_dep_maybe_enum_destr' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2)))
[@Norm]
let mk_dep_maybe_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
= dep_maybe_enum_destr_t_intro e v (mk_dep_maybe_enum_destr' e v [] e ())
(* Eliminators and destructors for verification purposes *) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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: (_: t -> Prims.GTot Type0) -> l: Prims.list t -> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.list",
"Prims.l_True",
"Prims.l_and",
"LowParse.Spec.Enum.list_forallp"
] | [
"recursion"
] | false | false | false | false | true | let rec list_forallp (#t: Type) (p: (t -> GTot Type0)) (l: list t) : GTot Type0 =
| match l with
| [] -> True
| a :: q -> p a /\ list_forallp p q | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.maybe_enum_key_of_repr'_t_cons_nil' | val maybe_enum_key_of_repr'_t_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit{Cons? e})
(u2: unit{Nil? (enum_tail' e)})
: Tot (maybe_enum_key_of_repr'_t e) | val maybe_enum_key_of_repr'_t_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit{Cons? e})
(u2: unit{Nil? (enum_tail' e)})
: Tot (maybe_enum_key_of_repr'_t e) | let maybe_enum_key_of_repr'_t_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail' e) } )
: Tot (maybe_enum_key_of_repr'_t e)
= maybe_enum_key_of_repr'_t_cons_nil e | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 38,
"end_line": 1312,
"start_col": 0,
"start_line": 1306
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d
inline_for_extraction
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
inline_for_extraction
let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } )
-> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
//NS: y is linear in the continuation after erasure
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@inline_let]
let _ = v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x)) in
y
) <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
(decreases l2)
= match l2 with
| [] -> dep_maybe_enum_destr_nil e v l1 l2 u1
| _ -> dep_maybe_enum_destr_cons e v l1 l2 u1 (mk_dep_maybe_enum_destr' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2)))
[@Norm]
let mk_dep_maybe_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
= dep_maybe_enum_destr_t_intro e v (mk_dep_maybe_enum_destr' e v [] e ())
(* Eliminators and destructors for verification purposes *)
let rec list_forallp (#t: Type) (p: t -> GTot Type0) (l: list t) : GTot Type0 =
match l with
| [] -> True
| a :: q -> p a /\ list_forallp p q
let rec list_forallp_mem (#t: eqtype) (p: t -> GTot Type0) (l: list t) : Lemma
(list_forallp p l <==> (forall x . L.mem x l ==> p x))
= match l with
| [] -> ()
| _ :: q -> list_forallp_mem p q
inline_for_extraction
let destruct_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> Tot Type)
(f_known: (
(x: key) ->
(u: squash (list_mem x (list_map fst e))) ->
Tot (f (Known x))
))
(f_unknown: (
(x: value) ->
(u: squash (list_mem x (list_map snd e) == false)) ->
Tot (f (Unknown x))
))
(x: maybe_enum_key e)
: Tot (f x)
= match x with
| Known x' -> f_known x' ()
| Unknown x' -> f_unknown x' ()
let forall_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> GTot Type0)
(f_known: squash (list_forallp (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e)))
(f_unknown: (
(x: value) ->
Tot (squash (list_mem x (list_map snd e) == false ==> f (Unknown x)))
))
: Tot (squash (forall (x: maybe_enum_key e) . f x))
= let g
(x: maybe_enum_key e)
: Lemma
(f x)
= let u : squash (f x) =
destruct_maybe_enum_key
e
(fun y -> squash (f y))
(fun x' u -> list_forallp_mem (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e))
(fun x' u -> f_unknown x') x
in
assert (f x)
in
Classical.forall_intro g
(* Converting enum keys to their representation, using combinators *)
let enum_repr_of_key'_t
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (x: enum_key e) ->
Tot (r: enum_repr e { r == enum_repr_of_key e x } )
inline_for_extraction
let enum_repr_of_key_cons
(#key #repr: eqtype)
(e: enum key repr)
(f : enum_repr_of_key'_t (enum_tail' e))
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, r) :: _ ->
(fun (x: enum_key e) -> (
if k = x
then (r <: repr)
else (f (x <: key) <: repr)
) <: (r: enum_repr e { enum_repr_of_key e x == r } )))
e
inline_for_extraction
let enum_repr_of_key_cons'
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(f : enum_repr_of_key'_t (enum_tail' e))
: Tot (enum_repr_of_key'_t e)
= enum_repr_of_key_cons e f
inline_for_extraction
let enum_repr_of_key_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| [(k, r)] ->
(fun (x: enum_key e) ->
(r <: (r: enum_repr e { enum_repr_of_key e x == r } ))))
e
inline_for_extraction
let enum_repr_of_key_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail' e) } )
: Tot (enum_repr_of_key'_t e)
= enum_repr_of_key_cons_nil e
let enum_repr_of_key_append_cons
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key & repr))
(kr: (key & repr))
(l2: list (key & repr))
: Lemma
(requires (e == l1 `L.append` (kr :: l2)))
(ensures (list_mem (fst kr) (list_map fst e) /\ enum_repr_of_key e (fst kr) == snd kr /\ list_mem (snd kr) (list_map snd e) /\ enum_key_of_repr e (snd kr) == fst kr))
= L.map_append fst l1 (kr :: l2);
L.noRepeats_append_elim (L.map fst l1) (L.map fst (kr :: l2));
L.assoc_mem (fst kr) l1;
L.assoc_mem (fst kr) e;
L.assoc_append_elim_l (fst kr) l1 (kr :: l2);
enum_key_of_repr_of_key e (fst kr)
let maybe_enum_key_of_repr'_t
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (x: repr) ->
Tot (k: maybe_enum_key e { k == maybe_enum_key_of_repr e x } )
#push-options "--z3rlimit 32"
inline_for_extraction
let maybe_enum_key_of_repr'_t_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
: Pure (maybe_enum_key_of_repr'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| [(k, r)] ->
(fun x -> ((
if r = x
then Known k
else Unknown x
) <: (k: maybe_enum_key e { k == maybe_enum_key_of_repr e x } ))))
e | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
key: Prims.eqtype ->
repr: Prims.eqtype ->
e: LowParse.Spec.Enum.enum key repr ->
u1: Prims.unit{Cons? e} ->
u2: Prims.unit{Nil? (LowParse.Spec.Enum.enum_tail' e)}
-> LowParse.Spec.Enum.maybe_enum_key_of_repr'_t e | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.unit",
"Prims.b2t",
"Prims.uu___is_Cons",
"FStar.Pervasives.Native.tuple2",
"Prims.uu___is_Nil",
"LowParse.Spec.Enum.enum_tail'",
"LowParse.Spec.Enum.maybe_enum_key_of_repr'_t_cons_nil",
"LowParse.Spec.Enum.maybe_enum_key_of_repr'_t"
] | [] | false | false | false | false | false | let maybe_enum_key_of_repr'_t_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit{Cons? e})
(u2: unit{Nil? (enum_tail' e)})
: Tot (maybe_enum_key_of_repr'_t e) =
| maybe_enum_key_of_repr'_t_cons_nil e | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.forall_maybe_enum_key | val forall_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: (maybe_enum_key e -> GTot Type0))
(f_known:
squash (list_forallp (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x))
(list_map fst e)))
(f_unknown:
(x: value -> Tot (squash (list_mem x (list_map snd e) == false ==> f (Unknown x)))))
: Tot (squash (forall (x: maybe_enum_key e). f x)) | val forall_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: (maybe_enum_key e -> GTot Type0))
(f_known:
squash (list_forallp (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x))
(list_map fst e)))
(f_unknown:
(x: value -> Tot (squash (list_mem x (list_map snd e) == false ==> f (Unknown x)))))
: Tot (squash (forall (x: maybe_enum_key e). f x)) | let forall_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> GTot Type0)
(f_known: squash (list_forallp (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e)))
(f_unknown: (
(x: value) ->
Tot (squash (list_mem x (list_map snd e) == false ==> f (Unknown x)))
))
: Tot (squash (forall (x: maybe_enum_key e) . f x))
= let g
(x: maybe_enum_key e)
: Lemma
(f x)
= let u : squash (f x) =
destruct_maybe_enum_key
e
(fun y -> squash (f y))
(fun x' u -> list_forallp_mem (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e))
(fun x' u -> f_unknown x') x
in
assert (f x)
in
Classical.forall_intro g | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 26,
"end_line": 1204,
"start_col": 0,
"start_line": 1181
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d
inline_for_extraction
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
inline_for_extraction
let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } )
-> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
//NS: y is linear in the continuation after erasure
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@inline_let]
let _ = v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x)) in
y
) <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
(decreases l2)
= match l2 with
| [] -> dep_maybe_enum_destr_nil e v l1 l2 u1
| _ -> dep_maybe_enum_destr_cons e v l1 l2 u1 (mk_dep_maybe_enum_destr' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2)))
[@Norm]
let mk_dep_maybe_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
= dep_maybe_enum_destr_t_intro e v (mk_dep_maybe_enum_destr' e v [] e ())
(* Eliminators and destructors for verification purposes *)
let rec list_forallp (#t: Type) (p: t -> GTot Type0) (l: list t) : GTot Type0 =
match l with
| [] -> True
| a :: q -> p a /\ list_forallp p q
let rec list_forallp_mem (#t: eqtype) (p: t -> GTot Type0) (l: list t) : Lemma
(list_forallp p l <==> (forall x . L.mem x l ==> p x))
= match l with
| [] -> ()
| _ :: q -> list_forallp_mem p q
inline_for_extraction
let destruct_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> Tot Type)
(f_known: (
(x: key) ->
(u: squash (list_mem x (list_map fst e))) ->
Tot (f (Known x))
))
(f_unknown: (
(x: value) ->
(u: squash (list_mem x (list_map snd e) == false)) ->
Tot (f (Unknown x))
))
(x: maybe_enum_key e)
: Tot (f x)
= match x with
| Known x' -> f_known x' ()
| Unknown x' -> f_unknown x' () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 |
e: LowParse.Spec.Enum.enum key value ->
f: (_: LowParse.Spec.Enum.maybe_enum_key e -> Prims.GTot Type0) ->
f_known:
Prims.squash (LowParse.Spec.Enum.list_forallp (fun x ->
LowParse.Spec.Enum.list_mem x
(LowParse.Spec.Enum.list_map FStar.Pervasives.Native.fst e) /\
f (LowParse.Spec.Enum.Known x))
(LowParse.Spec.Enum.list_map FStar.Pervasives.Native.fst e)) ->
f_unknown:
(x: value
-> Prims.squash (LowParse.Spec.Enum.list_mem x
(LowParse.Spec.Enum.list_map FStar.Pervasives.Native.snd e) ==
false ==>
f (LowParse.Spec.Enum.Unknown x)))
-> Prims.squash (forall (x: LowParse.Spec.Enum.maybe_enum_key e). f x) | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.maybe_enum_key",
"Prims.squash",
"LowParse.Spec.Enum.list_forallp",
"Prims.l_and",
"Prims.b2t",
"LowParse.Spec.Enum.list_mem",
"LowParse.Spec.Enum.list_map",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.fst",
"LowParse.Spec.Enum.Known",
"Prims.l_imp",
"Prims.eq2",
"Prims.bool",
"FStar.Pervasives.Native.snd",
"LowParse.Spec.Enum.Unknown",
"FStar.Classical.forall_intro",
"Prims.unit",
"Prims.l_True",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Prims._assert",
"LowParse.Spec.Enum.destruct_maybe_enum_key",
"LowParse.Spec.Enum.list_forallp_mem",
"Prims.l_Forall"
] | [] | false | false | true | false | false | let forall_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: (maybe_enum_key e -> GTot Type0))
(f_known:
squash (list_forallp (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x))
(list_map fst e)))
(f_unknown:
(x: value -> Tot (squash (list_mem x (list_map snd e) == false ==> f (Unknown x)))))
: Tot (squash (forall (x: maybe_enum_key e). f x)) =
| let g (x: maybe_enum_key e) : Lemma (f x) =
let u:squash (f x) =
destruct_maybe_enum_key e
(fun y -> squash (f y))
(fun x' u ->
list_forallp_mem (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x))
(list_map fst e))
(fun x' u -> f_unknown x')
x
in
assert (f x)
in
Classical.forall_intro g | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.maybe_enum_key_of_repr'_t_cons | val maybe_enum_key_of_repr'_t_cons
(#key #repr: eqtype)
(e: enum key repr)
(g: maybe_enum_key_of_repr'_t (enum_tail' e))
: Pure (maybe_enum_key_of_repr'_t e) (requires (Cons? e)) (ensures (fun _ -> True)) | val maybe_enum_key_of_repr'_t_cons
(#key #repr: eqtype)
(e: enum key repr)
(g: maybe_enum_key_of_repr'_t (enum_tail' e))
: Pure (maybe_enum_key_of_repr'_t e) (requires (Cons? e)) (ensures (fun _ -> True)) | let maybe_enum_key_of_repr'_t_cons
(#key #repr: eqtype)
(e: enum key repr )
(g : maybe_enum_key_of_repr'_t (enum_tail' e))
: Pure (maybe_enum_key_of_repr'_t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, r) :: _ ->
(fun x -> ((
if r = x
then Known k
else
let y : maybe_enum_key (enum_tail' e) = g x in
match y with
| Known k' -> Known (k' <: key)
| Unknown x' -> Unknown x
) <: (k: maybe_enum_key e { k == maybe_enum_key_of_repr e x } ))))
e | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 7,
"end_line": 1333,
"start_col": 0,
"start_line": 1315
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d
inline_for_extraction
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
inline_for_extraction
let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } )
-> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
//NS: y is linear in the continuation after erasure
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@inline_let]
let _ = v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x)) in
y
) <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
(decreases l2)
= match l2 with
| [] -> dep_maybe_enum_destr_nil e v l1 l2 u1
| _ -> dep_maybe_enum_destr_cons e v l1 l2 u1 (mk_dep_maybe_enum_destr' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2)))
[@Norm]
let mk_dep_maybe_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
= dep_maybe_enum_destr_t_intro e v (mk_dep_maybe_enum_destr' e v [] e ())
(* Eliminators and destructors for verification purposes *)
let rec list_forallp (#t: Type) (p: t -> GTot Type0) (l: list t) : GTot Type0 =
match l with
| [] -> True
| a :: q -> p a /\ list_forallp p q
let rec list_forallp_mem (#t: eqtype) (p: t -> GTot Type0) (l: list t) : Lemma
(list_forallp p l <==> (forall x . L.mem x l ==> p x))
= match l with
| [] -> ()
| _ :: q -> list_forallp_mem p q
inline_for_extraction
let destruct_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> Tot Type)
(f_known: (
(x: key) ->
(u: squash (list_mem x (list_map fst e))) ->
Tot (f (Known x))
))
(f_unknown: (
(x: value) ->
(u: squash (list_mem x (list_map snd e) == false)) ->
Tot (f (Unknown x))
))
(x: maybe_enum_key e)
: Tot (f x)
= match x with
| Known x' -> f_known x' ()
| Unknown x' -> f_unknown x' ()
let forall_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> GTot Type0)
(f_known: squash (list_forallp (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e)))
(f_unknown: (
(x: value) ->
Tot (squash (list_mem x (list_map snd e) == false ==> f (Unknown x)))
))
: Tot (squash (forall (x: maybe_enum_key e) . f x))
= let g
(x: maybe_enum_key e)
: Lemma
(f x)
= let u : squash (f x) =
destruct_maybe_enum_key
e
(fun y -> squash (f y))
(fun x' u -> list_forallp_mem (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e))
(fun x' u -> f_unknown x') x
in
assert (f x)
in
Classical.forall_intro g
(* Converting enum keys to their representation, using combinators *)
let enum_repr_of_key'_t
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (x: enum_key e) ->
Tot (r: enum_repr e { r == enum_repr_of_key e x } )
inline_for_extraction
let enum_repr_of_key_cons
(#key #repr: eqtype)
(e: enum key repr)
(f : enum_repr_of_key'_t (enum_tail' e))
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, r) :: _ ->
(fun (x: enum_key e) -> (
if k = x
then (r <: repr)
else (f (x <: key) <: repr)
) <: (r: enum_repr e { enum_repr_of_key e x == r } )))
e
inline_for_extraction
let enum_repr_of_key_cons'
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(f : enum_repr_of_key'_t (enum_tail' e))
: Tot (enum_repr_of_key'_t e)
= enum_repr_of_key_cons e f
inline_for_extraction
let enum_repr_of_key_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| [(k, r)] ->
(fun (x: enum_key e) ->
(r <: (r: enum_repr e { enum_repr_of_key e x == r } ))))
e
inline_for_extraction
let enum_repr_of_key_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail' e) } )
: Tot (enum_repr_of_key'_t e)
= enum_repr_of_key_cons_nil e
let enum_repr_of_key_append_cons
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key & repr))
(kr: (key & repr))
(l2: list (key & repr))
: Lemma
(requires (e == l1 `L.append` (kr :: l2)))
(ensures (list_mem (fst kr) (list_map fst e) /\ enum_repr_of_key e (fst kr) == snd kr /\ list_mem (snd kr) (list_map snd e) /\ enum_key_of_repr e (snd kr) == fst kr))
= L.map_append fst l1 (kr :: l2);
L.noRepeats_append_elim (L.map fst l1) (L.map fst (kr :: l2));
L.assoc_mem (fst kr) l1;
L.assoc_mem (fst kr) e;
L.assoc_append_elim_l (fst kr) l1 (kr :: l2);
enum_key_of_repr_of_key e (fst kr)
let maybe_enum_key_of_repr'_t
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (x: repr) ->
Tot (k: maybe_enum_key e { k == maybe_enum_key_of_repr e x } )
#push-options "--z3rlimit 32"
inline_for_extraction
let maybe_enum_key_of_repr'_t_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
: Pure (maybe_enum_key_of_repr'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| [(k, r)] ->
(fun x -> ((
if r = x
then Known k
else Unknown x
) <: (k: maybe_enum_key e { k == maybe_enum_key_of_repr e x } ))))
e
inline_for_extraction
let maybe_enum_key_of_repr'_t_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail' e) } )
: Tot (maybe_enum_key_of_repr'_t e)
= maybe_enum_key_of_repr'_t_cons_nil e | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
e: LowParse.Spec.Enum.enum key repr ->
g: LowParse.Spec.Enum.maybe_enum_key_of_repr'_t (LowParse.Spec.Enum.enum_tail' e)
-> Prims.Pure (LowParse.Spec.Enum.maybe_enum_key_of_repr'_t e) | Prims.Pure | [] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.maybe_enum_key_of_repr'_t",
"LowParse.Spec.Enum.enum_tail'",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.op_Equality",
"LowParse.Spec.Enum.Known",
"Prims.bool",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Enum.unknown_enum_repr",
"LowParse.Spec.Enum.Unknown",
"LowParse.Spec.Enum.maybe_enum_key",
"Prims.eq2",
"LowParse.Spec.Enum.maybe_enum_key_of_repr",
"Prims.b2t",
"Prims.uu___is_Cons",
"Prims.l_True"
] | [] | false | false | false | false | false | let maybe_enum_key_of_repr'_t_cons
(#key #repr: eqtype)
(e: enum key repr)
(g: maybe_enum_key_of_repr'_t (enum_tail' e))
: Pure (maybe_enum_key_of_repr'_t e) (requires (Cons? e)) (ensures (fun _ -> True)) =
| (fun (e': list (key * repr) {e' == e}) ->
match e' with
| (k, r) :: _ ->
(fun x ->
((if r = x
then Known k
else
let y:maybe_enum_key (enum_tail' e) = g x in
match y with
| Known k' -> Known (k' <: key)
| Unknown x' -> Unknown x)
<:
(k: maybe_enum_key e {k == maybe_enum_key_of_repr e x})))) e | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.dep_enum_destr_cons | val dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k': enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v) | val dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k': enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v) | let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } )) | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 42,
"end_line": 762,
"start_col": 0,
"start_line": 710
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 |
e: LowParse.Spec.Enum.enum key repr ->
u763: Prims.squash (Cons? e) ->
v: (_: LowParse.Spec.Enum.enum_key e -> Type) ->
destr: LowParse.Spec.Enum.dep_enum_destr (LowParse.Spec.Enum.enum_tail e) (fun k' -> v k')
-> LowParse.Spec.Enum.dep_enum_destr e v | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.squash",
"Prims.b2t",
"Prims.uu___is_Cons",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Enum.dep_enum_destr",
"LowParse.Spec.Enum.enum_tail",
"Prims.list",
"LowParse.Spec.Enum.if_combinator",
"LowParse.Spec.Enum.r_reflexive_t",
"LowParse.Spec.Enum.r_transitive_t",
"Prims.op_Equality",
"LowParse.Spec.Combinators.cond_true",
"LowParse.Spec.Combinators.cond_false",
"Prims.unit",
"Prims._assert",
"FStar.List.Tot.Base.mem",
"FStar.List.Tot.Base.map",
"FStar.Pervasives.Native.fst",
"Prims.op_disEquality",
"LowParse.Spec.Enum.r_transitive_t_elim",
"LowParse.Spec.Enum.r_reflexive_t_elim"
] | [] | false | false | false | false | false | let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k': enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v) =
| match e with
| (k, _) :: _ ->
fun
(v_eq: (k: enum_key e -> v k -> v k -> GTot Type0))
(v_if: (k: enum_key e -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: (k: enum_key e -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: (k: enum_key e -> Tot (r_transitive_t _ (v_eq k))))
(f: (k: enum_key e -> Tot (v k)))
(k': enum_key e)
->
[@@ inline_let ]let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@@ inline_let ]let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@@ inline_let ]let y:v k' =
v_if k'
(k = k')
(fun _ ->
[@@ inline_let ]let y:v k' = f k in
y)
(fun _ ->
[@@ inline_let ]let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@@ inline_let ]let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0)
=
v_eq (k <: key)
in
[@@ inline_let ]let v'_if (k: enum_key (enum_tail e))
: Tot (if_combinator (v' k) (v'_eq k)) =
v_if (k <: key)
in
[@@ inline_let ]let v'_eq_refl (k: enum_key (enum_tail e))
: Tot (r_reflexive_t _ (v'_eq k)) =
v_eq_refl (k <: key)
in
[@@ inline_let ]let v'_eq_trans (k: enum_key (enum_tail e))
: Tot (r_transitive_t _ (v'_eq k)) =
v_eq_trans (k <: key)
in
[@@ inline_let ]let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@@ inline_let ]let k':key = k' in
[@@ inline_let ]let _ = assert (k' <> k) in
[@@ inline_let ]let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@@ inline_let ]let y:v' k' = destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k' in
y)
in
(y <: (y: v k' {v_eq k' y (f k')})) | false |
LowParse.Spec.Enum.fst | LowParse.Spec.Enum.enum_repr_of_key_cons_nil' | val enum_repr_of_key_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit{Cons? e})
(u2: unit{Nil? (enum_tail' e)})
: Tot (enum_repr_of_key'_t e) | val enum_repr_of_key_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit{Cons? e})
(u2: unit{Nil? (enum_tail' e)})
: Tot (enum_repr_of_key'_t e) | let enum_repr_of_key_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail' e) } )
: Tot (enum_repr_of_key'_t e)
= enum_repr_of_key_cons_nil e | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 29,
"end_line": 1261,
"start_col": 0,
"start_line": 1255
} | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d
inline_for_extraction
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
inline_for_extraction
let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } )
-> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
//NS: y is linear in the continuation after erasure
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@inline_let]
let _ = v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x)) in
y
) <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
(decreases l2)
= match l2 with
| [] -> dep_maybe_enum_destr_nil e v l1 l2 u1
| _ -> dep_maybe_enum_destr_cons e v l1 l2 u1 (mk_dep_maybe_enum_destr' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2)))
[@Norm]
let mk_dep_maybe_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
= dep_maybe_enum_destr_t_intro e v (mk_dep_maybe_enum_destr' e v [] e ())
(* Eliminators and destructors for verification purposes *)
let rec list_forallp (#t: Type) (p: t -> GTot Type0) (l: list t) : GTot Type0 =
match l with
| [] -> True
| a :: q -> p a /\ list_forallp p q
let rec list_forallp_mem (#t: eqtype) (p: t -> GTot Type0) (l: list t) : Lemma
(list_forallp p l <==> (forall x . L.mem x l ==> p x))
= match l with
| [] -> ()
| _ :: q -> list_forallp_mem p q
inline_for_extraction
let destruct_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> Tot Type)
(f_known: (
(x: key) ->
(u: squash (list_mem x (list_map fst e))) ->
Tot (f (Known x))
))
(f_unknown: (
(x: value) ->
(u: squash (list_mem x (list_map snd e) == false)) ->
Tot (f (Unknown x))
))
(x: maybe_enum_key e)
: Tot (f x)
= match x with
| Known x' -> f_known x' ()
| Unknown x' -> f_unknown x' ()
let forall_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> GTot Type0)
(f_known: squash (list_forallp (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e)))
(f_unknown: (
(x: value) ->
Tot (squash (list_mem x (list_map snd e) == false ==> f (Unknown x)))
))
: Tot (squash (forall (x: maybe_enum_key e) . f x))
= let g
(x: maybe_enum_key e)
: Lemma
(f x)
= let u : squash (f x) =
destruct_maybe_enum_key
e
(fun y -> squash (f y))
(fun x' u -> list_forallp_mem (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e))
(fun x' u -> f_unknown x') x
in
assert (f x)
in
Classical.forall_intro g
(* Converting enum keys to their representation, using combinators *)
let enum_repr_of_key'_t
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (x: enum_key e) ->
Tot (r: enum_repr e { r == enum_repr_of_key e x } )
inline_for_extraction
let enum_repr_of_key_cons
(#key #repr: eqtype)
(e: enum key repr)
(f : enum_repr_of_key'_t (enum_tail' e))
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, r) :: _ ->
(fun (x: enum_key e) -> (
if k = x
then (r <: repr)
else (f (x <: key) <: repr)
) <: (r: enum_repr e { enum_repr_of_key e x == r } )))
e
inline_for_extraction
let enum_repr_of_key_cons'
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(f : enum_repr_of_key'_t (enum_tail' e))
: Tot (enum_repr_of_key'_t e)
= enum_repr_of_key_cons e f
inline_for_extraction
let enum_repr_of_key_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| [(k, r)] ->
(fun (x: enum_key e) ->
(r <: (r: enum_repr e { enum_repr_of_key e x == r } ))))
e | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"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 |
key: Prims.eqtype ->
repr: Prims.eqtype ->
e: LowParse.Spec.Enum.enum key repr ->
u1: Prims.unit{Cons? e} ->
u2: Prims.unit{Nil? (LowParse.Spec.Enum.enum_tail' e)}
-> LowParse.Spec.Enum.enum_repr_of_key'_t e | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.unit",
"Prims.b2t",
"Prims.uu___is_Cons",
"FStar.Pervasives.Native.tuple2",
"Prims.uu___is_Nil",
"LowParse.Spec.Enum.enum_tail'",
"LowParse.Spec.Enum.enum_repr_of_key_cons_nil",
"LowParse.Spec.Enum.enum_repr_of_key'_t"
] | [] | false | false | false | false | false | let enum_repr_of_key_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit{Cons? e})
(u2: unit{Nil? (enum_tail' e)})
: Tot (enum_repr_of_key'_t e) =
| enum_repr_of_key_cons_nil e | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.