Datasets:

microsoft

/

FStarDataSet-V2

like 0

FStar.Stubs.Tactics.Types.fsti

FStar.Stubs.Tactics.Types.issues

val issues : Type0

let issues = list FStar.Issue.issue

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.Stubs.Tactics.Types open FStar.Stubs.Reflection.Types include FStar.Stubs.Tactics.Common include FStar.Stubs.TypeChecker.Core assume new type goal assume new type proofstate (* Returns the active goals *) val goals_of : proofstate -> list goal (* Returns the goals marked for SMT *) val smt_goals_of : proofstate -> list goal (* Inspecting a goal *) val goal_env : goal -> env val goal_type : goal -> typ val goal_witness : goal -> term val is_guard : goal -> bool (* A bit of helper info: did this goal come from a VC guard? *) val get_label : goal -> string val set_label : string -> goal -> goal (* Tracing *) val incr_depth : proofstate -> proofstate val decr_depth : proofstate -> proofstate (* [tracepoint] always returns true. We do not use unit to prevent erasure. *) val tracepoint : proofstate -> b:bool{b == true} val set_proofstate_range : proofstate -> FStar.Range.range -> proofstate type direction = | TopDown | BottomUp type ctrl_flag = | Continue | Skip | Abort type guard_policy = | Goal // Add guards as (normal) goals | SMT // Add guards as SMT goals | SMTSync // Send guards to SMT immediately, will *log* errors (not raise) if anything fails | Force // Force guards without SMT | Drop // Drop guards, clearly unsound! careful! (* Typing reflection *) val non_informative_token (g:env) (t:typ) : Type0 val subtyping_token (g:env) (t0 t1:typ) : Type0 val equiv_token (g:env) (t0 t1:typ) : Type0 val typing_token (g:env) (e:term) (c:tot_or_ghost & typ) : Type0 (* Must be inline, this definition is not there in src/FStar.Tactics.Types *)

Type0

Prims.Tot

let issues =

list FStar.Issue.issue

Vale.Inline.X64.Fadd_inline.fsti

Vale.Inline.X64.Fadd_inline.u1024

val u1024 : Type0

let u1024 = b:B.buffer UInt64.t{B.length b == 16}

module Vale.Inline.X64.Fadd_inline open Vale.X64.CPU_Features_s open FStar.HyperStack.ST module B = LowStar.Buffer module HS = FStar.HyperStack open Vale.Curve25519.Fast_defs open FStar.Mul unfold let u256 = b:B.buffer UInt64.t{B.length b == 4} unfold let u512 = b:B.buffer UInt64.t{B.length b == 8}

Type0

Prims.Tot

let u1024 =

b: B.buffer UInt64.t {B.length b == 16}

Vale.Inline.X64.Fadd_inline.fsti

Vale.Inline.X64.Fadd_inline.u256

val u256 : Type0

let u256 = b:B.buffer UInt64.t{B.length b == 4}

module Vale.Inline.X64.Fadd_inline open Vale.X64.CPU_Features_s open FStar.HyperStack.ST module B = LowStar.Buffer module HS = FStar.HyperStack open Vale.Curve25519.Fast_defs open FStar.Mul

Type0

Prims.Tot

let u256 =

b: B.buffer UInt64.t {B.length b == 4}

Vale.Inline.X64.Fadd_inline.fsti

Vale.Inline.X64.Fadd_inline.u512

val u512 : Type0

let u512 = b:B.buffer UInt64.t{B.length b == 8}

module Vale.Inline.X64.Fadd_inline open Vale.X64.CPU_Features_s open FStar.HyperStack.ST module B = LowStar.Buffer module HS = FStar.HyperStack open Vale.Curve25519.Fast_defs open FStar.Mul unfold let u256 = b:B.buffer UInt64.t{B.length b == 4}

Type0

Prims.Tot

let u512 =

b: B.buffer UInt64.t {B.length b == 8}

Pulse.Elaborate.Core.fst

Pulse.Elaborate.Core.elab_st_sub

val elab_st_sub (#g: env) (#c1 #c2: comp) (d_sub: st_sub g c1 c2) : Tot (t: R.term & RT.tot_typing (elab_env g) t (simple_arr (elab_comp c1) (elab_comp c2)))

val elab_st_sub (#g: env) (#c1 #c2: comp) (d_sub: st_sub g c1 c2) : Tot (t: R.term & RT.tot_typing (elab_env g) t (simple_arr (elab_comp c1) (elab_comp c2)))

let elab_st_sub (#g:env) (#c1 #c2 : comp) (d_sub : st_sub g c1 c2) : Tot (t:R.term & RT.tot_typing (elab_env g) t (simple_arr (elab_comp c1) (elab_comp c2))) = RU.magic_s "elab_st_sub"

(* 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.Elaborate.Core module RT = FStar.Reflection.Typing module R = FStar.Reflection.V2 module L = FStar.List.Tot module T = FStar.Tactics.V2 open FStar.List.Tot open Pulse.Syntax open Pulse.Elaborate.Pure open Pulse.Typing module RU = Pulse.RuntimeUtils open Pulse.Reflection.Util let elab_frame (c:comp_st) (frame:term) (e:R.term) = let u = comp_u c in let ty = elab_term (comp_res c) in let pre = elab_term (comp_pre c) in let post = elab_term (comp_post c) in if C_ST? c then mk_frame_stt u ty pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e else if C_STAtomic? c then let opened = elab_term (comp_inames c) in mk_frame_stt_atomic u ty opened pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e else mk_frame_stt_ghost u ty pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e let elab_sub (c1 c2:comp_st) (e:R.term) = let ty = elab_term (comp_res c1) in let u = comp_u c1 in let pre1 = elab_term (comp_pre c1) in let pre2 = elab_term (comp_pre c2) in let post1 = mk_abs ty R.Q_Explicit (elab_term (comp_post c1)) in let post2 = mk_abs ty R.Q_Explicit (elab_term (comp_post c2)) in if C_ST? c1 then mk_sub_stt u ty pre1 pre2 post1 post2 e else if C_STAtomic? c1 then let opened = elab_term (comp_inames c1) in mk_sub_stt_atomic u ty opened pre1 pre2 post1 post2 e else mk_sub_stt_ghost u ty pre1 pre2 post1 post2 e let elab_bind #g #x #c1 #c2 #c (bc:bind_comp g x c1 c2 c) (e1 e2:R.term) : R.term = let t1 = elab_term (comp_res c1) in let t2 = elab_term (comp_res c2) in match c1 with | C_ST _ -> mk_bind_stt (comp_u c1) (comp_u c2) t1 t2 (elab_term (comp_pre c1)) (mk_abs t1 R.Q_Explicit (elab_term (comp_post c1))) (mk_abs t2 R.Q_Explicit (elab_term (comp_post c2))) e1 e2 | C_STGhost _ -> mk_bind_ghost (comp_u c1) (comp_u c2) t1 t2 (elab_term (comp_pre c1)) (mk_abs t1 R.Q_Explicit (elab_term (comp_post c1))) (mk_abs t2 R.Q_Explicit (elab_term (comp_post c2))) e1 e2 | C_STAtomic inames obs1 _ -> let C_STAtomic _ obs2 _ = c2 in mk_bind_atomic (comp_u c1) (comp_u c2) (elab_observability obs1) (elab_observability obs2) (elab_term (comp_inames c1)) t1 t2 (elab_term (comp_pre c1)) (mk_abs t1 R.Q_Explicit (elab_term (comp_post c1))) (mk_abs t2 R.Q_Explicit (elab_term (comp_post c2))) e1 e2 let elab_lift #g #c1 #c2 (d:lift_comp g c1 c2) (e:R.term) : Tot R.term = match d with | Lift_STAtomic_ST _ _ -> let t = elab_term (comp_res c1) in mk_lift_atomic_stt (comp_u c1) (elab_term (comp_res c1)) t (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e | Lift_Observability _ c o2 -> let t = elab_term (comp_res c1) in mk_lift_observability (comp_u c1) (elab_observability (C_STAtomic?.obs c)) (elab_observability o2) (elab_term (comp_inames c1)) t (elab_term (comp_pre c1)) (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e | Lift_Ghost_Neutral _ _ (| reveal_a, reveal_a_typing |) -> let t = elab_term (comp_res c1) in mk_lift_ghost_neutral (comp_u c1) t (elab_term (comp_pre c1)) (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e (elab_term reveal_a) | Lift_Neutral_Ghost _ c -> let t = elab_term (comp_res c1) in mk_lift_neutral_ghost (comp_u c1) t (elab_term (comp_pre c1)) (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e let intro_pure_tm (p:term) = let open Pulse.Reflection.Util in wtag (Some STT_Ghost) (Tm_STApp { head = tm_pureapp (tm_fvar (as_fv (mk_pulse_lib_core_lid "intro_pure"))) None p; arg_qual = None; arg = tm_fstar (`()) Range.range_0 }) let simple_arr (t1 t2 : R.term) : R.term = let b = R.pack_binder { sort = t1; ppname = Sealed.seal "x"; qual = R.Q_Explicit; attrs = [] } in R.pack_ln (R.Tv_Arrow b (R.pack_comp (R.C_Total t2)))

d_sub: Pulse.Typing.st_sub g c1 c2 -> Prims.dtuple2 FStar.Stubs.Reflection.Types.term (fun t -> FStar.Reflection.Typing.tot_typing (Pulse.Typing.elab_env g) t (Pulse.Elaborate.Core.simple_arr (Pulse.Elaborate.Pure.elab_comp c1) (Pulse.Elaborate.Pure.elab_comp c2)))

Prims.Tot

let elab_st_sub (#g: env) (#c1 #c2: comp) (d_sub: st_sub g c1 c2) : Tot (t: R.term & RT.tot_typing (elab_env g) t (simple_arr (elab_comp c1) (elab_comp c2))) =

RU.magic_s "elab_st_sub"

Pulse.Checker.IntroPure.fst

Pulse.Checker.IntroPure.check_prop_validity

val check_prop_validity (g: env) (p: term) (typing: tot_typing g p tm_prop) : T.Tac (prop_validity g p)

val check_prop_validity (g: env) (p: term) (typing: tot_typing g p tm_prop) : T.Tac (prop_validity g p)

let check_prop_validity (g:env) (p:term) (typing:tot_typing g p tm_prop): T.Tac (prop_validity g p) = Pulse.Checker.Pure.check_prop_validity g p typing

(* 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.IntroPure open Pulse.Syntax open Pulse.Typing open Pulse.Checker.Base open Pulse.Checker.Prover module T = FStar.Tactics.V2 module P = Pulse.Syntax.Printer let check_prop (g:env) (p:term) : T.Tac (p:term & tot_typing g p tm_prop) = let p0 = p in let (| p, p_typing |) = Pulse.Checker.Pure.check_vprop g (tm_pure p) in match p.t with | Tm_Pure pp -> let prop_typing = Pulse.Typing.Metatheory.pure_typing_inversion #_ #pp p_typing in (| pp, prop_typing |) | _ -> fail g None (Printf.sprintf "Impossible: check_intro_pure: checking a pure vprop %s returned a non-pure vprop %s,\ please file a bug-report" (P.term_to_string (tm_pure p0)) (P.term_to_string p))

g: Pulse.Typing.Env.env -> p: Pulse.Syntax.Base.term -> typing: Pulse.Typing.tot_typing g p Pulse.Typing.tm_prop -> FStar.Tactics.Effect.Tac (Pulse.Typing.prop_validity g p)

FStar.Tactics.Effect.Tac

let check_prop_validity (g: env) (p: term) (typing: tot_typing g p tm_prop) : T.Tac (prop_validity g p) =

Pulse.Checker.Pure.check_prop_validity g p typing

Vale.Inline.X64.Fadd_inline.fsti

Vale.Inline.X64.Fadd_inline.as_nat

val as_nat (b: B.buffer UInt64.t {B.length b == 4}) (h: HS.mem) : GTot nat

val as_nat (b: B.buffer UInt64.t {B.length b == 4}) (h: HS.mem) : GTot nat

let as_nat (b:B.buffer UInt64.t{B.length b == 4}) (h:HS.mem) : GTot nat = let s = B.as_seq h b in let s0 = UInt64.v (Seq.index s 0) in let s1 = UInt64.v (Seq.index s 1) in let s2 = UInt64.v (Seq.index s 2) in let s3 = UInt64.v (Seq.index s 3) in pow2_four s0 s1 s2 s3

module Vale.Inline.X64.Fadd_inline open Vale.X64.CPU_Features_s open FStar.HyperStack.ST module B = LowStar.Buffer module HS = FStar.HyperStack open Vale.Curve25519.Fast_defs open FStar.Mul unfold let u256 = b:B.buffer UInt64.t{B.length b == 4} unfold let u512 = b:B.buffer UInt64.t{B.length b == 8} unfold let u1024 = b:B.buffer UInt64.t{B.length b == 16}

b: LowStar.Buffer.buffer FStar.UInt64.t {LowStar.Monotonic.Buffer.length b == 4} -> h: FStar.Monotonic.HyperStack.mem -> Prims.GTot Prims.nat

Prims.GTot

let as_nat (b: B.buffer UInt64.t {B.length b == 4}) (h: HS.mem) : GTot nat =

let s = B.as_seq h b in let s0 = UInt64.v (Seq.index s 0) in let s1 = UInt64.v (Seq.index s 1) in let s2 = UInt64.v (Seq.index s 2) in let s3 = UInt64.v (Seq.index s 3) in pow2_four s0 s1 s2 s3

Vale.Stdcalls.X64.Aes.fst

Vale.Stdcalls.X64.Aes.aes128_key_expansion

val aes128_key_expansion : normal lowstar_key128_t

val aes128_key_expansion : normal lowstar_key128_t

let aes128_key_expansion //: normal lowstar_key128_t = as_normal_t #lowstar_key128_t lowstar_key128

module Vale.Stdcalls.X64.Aes open FStar.Mul open FStar.HyperStack.ST module HS = FStar.HyperStack module B = LowStar.Buffer module DV = LowStar.BufferView.Down module UV = LowStar.BufferView.Up open Vale.Def.Types_s open Vale.Interop.Base module IX64 = Vale.Interop.X64 module VSig = Vale.AsLowStar.ValeSig module LSig = Vale.AsLowStar.LowStarSig module ME = Vale.X64.Memory module V = Vale.X64.Decls module IA = Vale.Interop.Assumptions module W = Vale.AsLowStar.Wrapper open Vale.X64.MemoryAdapters module VS = Vale.X64.State module MS = Vale.X64.Machine_s let lowstar_key128 : lowstar_key128_t = assert_norm (List.length dom + List.length ([]<:list arg) <= 4); IX64.wrap_weak_stdcall code_key128 dom (W.mk_prediction code_key128 dom [] (key128_lemma code_key128 IA.win))

Vale.Interop.Base.normal Vale.Stdcalls.X64.Aes.lowstar_key128_t

Prims.Tot

let aes128_key_expansion =

as_normal_t #lowstar_key128_t lowstar_key128

Vale.Stdcalls.X64.Aes.fst

Vale.Stdcalls.X64.Aes.aes256_key_expansion

val aes256_key_expansion : normal lowstar_key256_t

val aes256_key_expansion : normal lowstar_key256_t

let aes256_key_expansion //: normal lowstar_key256_t = as_normal_t #lowstar_key256_t lowstar_key256

module Vale.Stdcalls.X64.Aes open FStar.Mul open FStar.HyperStack.ST module HS = FStar.HyperStack module B = LowStar.Buffer module DV = LowStar.BufferView.Down module UV = LowStar.BufferView.Up open Vale.Def.Types_s open Vale.Interop.Base module IX64 = Vale.Interop.X64 module VSig = Vale.AsLowStar.ValeSig module LSig = Vale.AsLowStar.LowStarSig module ME = Vale.X64.Memory module V = Vale.X64.Decls module IA = Vale.Interop.Assumptions module W = Vale.AsLowStar.Wrapper open Vale.X64.MemoryAdapters module VS = Vale.X64.State module MS = Vale.X64.Machine_s let lowstar_key128 : lowstar_key128_t = assert_norm (List.length dom + List.length ([]<:list arg) <= 4); IX64.wrap_weak_stdcall code_key128 dom (W.mk_prediction code_key128 dom [] (key128_lemma code_key128 IA.win)) let aes128_key_expansion //: normal lowstar_key128_t = as_normal_t #lowstar_key128_t lowstar_key128 let lowstar_key256 : lowstar_key256_t = assert_norm (List.length dom + List.length ([]<:list arg) <= 4); IX64.wrap_weak_stdcall code_key256 dom (W.mk_prediction code_key256 dom [] (key256_lemma code_key256 IA.win))

Vale.Interop.Base.normal Vale.Stdcalls.X64.Aes.lowstar_key256_t

Prims.Tot

let aes256_key_expansion =

as_normal_t #lowstar_key256_t lowstar_key256

IfcRulesReify.fst

IfcRulesReify.op_Less

val op_Less : label -> label -> Tot bool

val op_Less : label -> label -> Tot bool

let op_Less l1 l2 = match l1, l2 with | Low,High -> true | _, _ -> false

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module IfcRulesReify open Rel open WhileReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreExcFixed open FStar.Squash open FStar.Classical (****************************** Preliminaries ******************************) (* CH: Everything specialized to 2-point lattice *) type label = | Low | High

l1: IfcRulesReify.label -> l2: IfcRulesReify.label -> Prims.bool

Prims.Tot

let ( < ) l1 l2 =

match l1, l2 with | Low, High -> true | _, _ -> false

IfcRulesReify.fst

IfcRulesReify.op_Less_Equals

val op_Less_Equals : label -> label -> Tot bool

val op_Less_Equals : label -> label -> Tot bool

let op_Less_Equals l1 l2 = match l1, l2 with | High,Low -> false | _, _ -> true

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module IfcRulesReify open Rel open WhileReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreExcFixed open FStar.Squash open FStar.Classical (****************************** Preliminaries ******************************) (* CH: Everything specialized to 2-point lattice *) type label = | Low | High val op_Less : label -> label -> Tot bool let op_Less l1 l2 = match l1, l2 with | Low,High -> true | _, _ -> false

l1: IfcRulesReify.label -> l2: IfcRulesReify.label -> Prims.bool

Prims.Tot

let ( <= ) l1 l2 =

match l1, l2 with | High, Low -> false | _, _ -> true

IfcRulesReify.fst

IfcRulesReify.ni_exp

val ni_exp (env: label_fun) (e: exp) (l: label) : Tot Type0

val ni_exp (env: label_fun) (e: exp) (l: label) : Tot Type0

let ni_exp (env:label_fun) (e:exp) (l:label) : Tot Type0 = forall (h: rel heap). (* {:pattern (low_equiv env h)} *) (low_equiv env h /\ Low? l) ==> (* interpret_exp (R?.r h) e = interpret_exp (R?.l h) e *) begin let vr = reify (interpret_exp_st e) (R?.r h)in let vl = reify (interpret_exp_st e) (R?.l h) in vr = vl end

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module IfcRulesReify open Rel open WhileReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreExcFixed open FStar.Squash open FStar.Classical (****************************** Preliminaries ******************************) (* CH: Everything specialized to 2-point lattice *) type label = | Low | High val op_Less : label -> label -> Tot bool let op_Less l1 l2 = match l1, l2 with | Low,High -> true | _, _ -> false val op_Less_Equals : label -> label -> Tot bool let op_Less_Equals l1 l2 = match l1, l2 with | High,Low -> false | _, _ -> true val join : label -> label -> Tot label let join l1 l2 = match l1, l2 with | Low,Low -> Low | _, _ -> High val meet : label -> label -> Tot label let meet l1 l2 = match l1, l2 with | High, High -> High | _, _ -> Low let universal_property_meet l l1 l2 : Lemma (requires (l <= l1 /\ l <= l2)) (ensures (l <= meet l1 l2)) = () type label_fun = id -> Tot label type low_equiv (env:label_fun) (h1:rel heap) = (forall (x:id). (* {:pattern (env x)} *) env x = Low ==> index (R?.l h1) x = index (R?.r h1) x) (**************************** Typing Judgements ****************************) (* env |- e : l - Expressions do not modify the heap - Correctness - Low equivalent input heaps + Low label ==> same result

env: IfcRulesReify.label_fun -> e: WhileReify.exp -> l: IfcRulesReify.label -> Type0

Prims.Tot

let ni_exp (env: label_fun) (e: exp) (l: label) : Tot Type0 =

forall (h: rel heap). (low_equiv env h /\ Low? l) ==> (let vr = reify (interpret_exp_st e) (R?.r h) in let vl = reify (interpret_exp_st e) (R?.l h) in vr = vl)

IfcRulesReify.fst

IfcRulesReify.join

val join : label -> label -> Tot label

val join : label -> label -> Tot label

let join l1 l2 = match l1, l2 with | Low,Low -> Low | _, _ -> High

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module IfcRulesReify open Rel open WhileReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreExcFixed open FStar.Squash open FStar.Classical (****************************** Preliminaries ******************************) (* CH: Everything specialized to 2-point lattice *) type label = | Low | High val op_Less : label -> label -> Tot bool let op_Less l1 l2 = match l1, l2 with | Low,High -> true | _, _ -> false val op_Less_Equals : label -> label -> Tot bool let op_Less_Equals l1 l2 = match l1, l2 with | High,Low -> false | _, _ -> true

l1: IfcRulesReify.label -> l2: IfcRulesReify.label -> IfcRulesReify.label

Prims.Tot

let join l1 l2 =

match l1, l2 with | Low, Low -> Low | _, _ -> High

IfcRulesReify.fst

IfcRulesReify.meet

val meet : label -> label -> Tot label

val meet : label -> label -> Tot label

let meet l1 l2 = match l1, l2 with | High, High -> High | _, _ -> Low

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module IfcRulesReify open Rel open WhileReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreExcFixed open FStar.Squash open FStar.Classical (****************************** Preliminaries ******************************) (* CH: Everything specialized to 2-point lattice *) type label = | Low | High val op_Less : label -> label -> Tot bool let op_Less l1 l2 = match l1, l2 with | Low,High -> true | _, _ -> false val op_Less_Equals : label -> label -> Tot bool let op_Less_Equals l1 l2 = match l1, l2 with | High,Low -> false | _, _ -> true val join : label -> label -> Tot label let join l1 l2 = match l1, l2 with | Low,Low -> Low | _, _ -> High

l1: IfcRulesReify.label -> l2: IfcRulesReify.label -> IfcRulesReify.label

Prims.Tot

let meet l1 l2 =

match l1, l2 with | High, High -> High | _, _ -> Low

IfcRulesReify.fst

IfcRulesReify.ni_com'

val ni_com' (env: label_fun) (c: com) (l: label) (h0: rel heap) : Tot Type0

val ni_com' (env: label_fun) (c: com) (l: label) (h0: rel heap) : Tot Type0

let ni_com' (env:label_fun) (c:com) (l:label) (h0:rel heap) : Tot Type0 = let R h0l h0r = h0 in (* KM : That's the code that we would like to write but subtyping and matching on pairs interplay badly *) (* it generates a VC which boils down to [forall (h1l:heap). length h1l = length h0l] which is obviously false *) (* begin match interpret_com h0l c, interpret_com h0r c with *) (* | Some h1l, Some h1r -> low_equiv env (R h0l h0r) ==> low_equiv env (R h1l h1r) *) (* | _ -> True *) (* end *) begin match interpret_com h0l c with | Some h1l -> begin match interpret_com h0r c with | Some h1r -> low_equiv env h0 ==> low_equiv env (R h1l h1r) | _ -> True end | _ -> True end

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module IfcRulesReify open Rel open WhileReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreExcFixed open FStar.Squash open FStar.Classical (****************************** Preliminaries ******************************) (* CH: Everything specialized to 2-point lattice *) type label = | Low | High val op_Less : label -> label -> Tot bool let op_Less l1 l2 = match l1, l2 with | Low,High -> true | _, _ -> false val op_Less_Equals : label -> label -> Tot bool let op_Less_Equals l1 l2 = match l1, l2 with | High,Low -> false | _, _ -> true val join : label -> label -> Tot label let join l1 l2 = match l1, l2 with | Low,Low -> Low | _, _ -> High val meet : label -> label -> Tot label let meet l1 l2 = match l1, l2 with | High, High -> High | _, _ -> Low let universal_property_meet l l1 l2 : Lemma (requires (l <= l1 /\ l <= l2)) (ensures (l <= meet l1 l2)) = () type label_fun = id -> Tot label type low_equiv (env:label_fun) (h1:rel heap) = (forall (x:id). (* {:pattern (env x)} *) env x = Low ==> index (R?.l h1) x = index (R?.r h1) x) (**************************** Typing Judgements ****************************) (* env |- e : l - Expressions do not modify the heap - Correctness - Low equivalent input heaps + Low label ==> same result *) let ni_exp (env:label_fun) (e:exp) (l:label) : Tot Type0 = forall (h: rel heap). (* {:pattern (low_equiv env h)} *) (low_equiv env h /\ Low? l) ==> (* interpret_exp (R?.r h) e = interpret_exp (R?.l h) e *) begin let vr = reify (interpret_exp_st e) (R?.r h)in let vl = reify (interpret_exp_st e) (R?.l h) in vr = vl end (* env,pc:l |- c - References with a label below l are not modified - Total correctness - Low equivalent input heaps ==> Low equivalent output heaps *) let inv_com' (env:label_fun) (c:com) (l:label) (h0:heap) : Tot Type0 = match interpret_com h0 c with | None -> True | Some h1 -> forall (i:id). (* {:pattern (env i < l)} *) env i < l ==> index h0 i = index h1 i

env: IfcRulesReify.label_fun -> c: WhileReify.com -> l: IfcRulesReify.label -> h0: Rel.rel FStar.DM4F.Heap.IntStoreFixed.heap -> Type0

Prims.Tot

let ni_com' (env: label_fun) (c: com) (l: label) (h0: rel heap) : Tot Type0 =

let R h0l h0r = h0 in match interpret_com h0l c with | Some h1l -> (match interpret_com h0r c with | Some h1r -> low_equiv env h0 ==> low_equiv env (R h1l h1r) | _ -> True) | _ -> True

IfcRulesReify.fst

IfcRulesReify.ni_com

val ni_com (env: label_fun) (c: com) (l: label) : Tot Type0

val ni_com (env: label_fun) (c: com) (l: label) : Tot Type0

let ni_com (env:label_fun) (c:com) (l:label) : Tot Type0 = (forall (h0: rel heap). (* {:pattern (low_equiv env h0)} *) ni_com' env c l h0) /\ (forall (h0:heap). (* {:pattern (Some? (interpret_com h0 c))} *) inv_com' env c l h0)

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module IfcRulesReify open Rel open WhileReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreExcFixed open FStar.Squash open FStar.Classical (****************************** Preliminaries ******************************) (* CH: Everything specialized to 2-point lattice *) type label = | Low | High val op_Less : label -> label -> Tot bool let op_Less l1 l2 = match l1, l2 with | Low,High -> true | _, _ -> false val op_Less_Equals : label -> label -> Tot bool let op_Less_Equals l1 l2 = match l1, l2 with | High,Low -> false | _, _ -> true val join : label -> label -> Tot label let join l1 l2 = match l1, l2 with | Low,Low -> Low | _, _ -> High val meet : label -> label -> Tot label let meet l1 l2 = match l1, l2 with | High, High -> High | _, _ -> Low let universal_property_meet l l1 l2 : Lemma (requires (l <= l1 /\ l <= l2)) (ensures (l <= meet l1 l2)) = () type label_fun = id -> Tot label type low_equiv (env:label_fun) (h1:rel heap) = (forall (x:id). (* {:pattern (env x)} *) env x = Low ==> index (R?.l h1) x = index (R?.r h1) x) (**************************** Typing Judgements ****************************) (* env |- e : l - Expressions do not modify the heap - Correctness - Low equivalent input heaps + Low label ==> same result *) let ni_exp (env:label_fun) (e:exp) (l:label) : Tot Type0 = forall (h: rel heap). (* {:pattern (low_equiv env h)} *) (low_equiv env h /\ Low? l) ==> (* interpret_exp (R?.r h) e = interpret_exp (R?.l h) e *) begin let vr = reify (interpret_exp_st e) (R?.r h)in let vl = reify (interpret_exp_st e) (R?.l h) in vr = vl end (* env,pc:l |- c - References with a label below l are not modified - Total correctness - Low equivalent input heaps ==> Low equivalent output heaps *) let inv_com' (env:label_fun) (c:com) (l:label) (h0:heap) : Tot Type0 = match interpret_com h0 c with | None -> True | Some h1 -> forall (i:id). (* {:pattern (env i < l)} *) env i < l ==> index h0 i = index h1 i let ni_com' (env:label_fun) (c:com) (l:label) (h0:rel heap) : Tot Type0 = let R h0l h0r = h0 in (* KM : That's the code that we would like to write but subtyping and matching on pairs interplay badly *) (* it generates a VC which boils down to [forall (h1l:heap). length h1l = length h0l] which is obviously false *) (* begin match interpret_com h0l c, interpret_com h0r c with *) (* | Some h1l, Some h1r -> low_equiv env (R h0l h0r) ==> low_equiv env (R h1l h1r) *) (* | _ -> True *) (* end *) begin match interpret_com h0l c with | Some h1l -> begin match interpret_com h0r c with | Some h1r -> low_equiv env h0 ==> low_equiv env (R h1l h1r) | _ -> True end | _ -> True end

env: IfcRulesReify.label_fun -> c: WhileReify.com -> l: IfcRulesReify.label -> Type0

Prims.Tot

let ni_com (env: label_fun) (c: com) (l: label) : Tot Type0 =

(forall (h0: rel heap). ni_com' env c l h0) /\ (forall (h0: heap). inv_com' env c l h0)

Pulse.Elaborate.Core.fst

Pulse.Elaborate.Core.elab_frame

val elab_frame : c: Pulse.Syntax.Base.comp_st -> frame: Pulse.Syntax.Base.term -> e: FStar.Stubs.Reflection.Types.term -> FStar.Stubs.Reflection.Types.term

let elab_frame (c:comp_st) (frame:term) (e:R.term) = let u = comp_u c in let ty = elab_term (comp_res c) in let pre = elab_term (comp_pre c) in let post = elab_term (comp_post c) in if C_ST? c then mk_frame_stt u ty pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e else if C_STAtomic? c then let opened = elab_term (comp_inames c) in mk_frame_stt_atomic u ty opened pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e else mk_frame_stt_ghost u ty pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e

(* 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.Elaborate.Core module RT = FStar.Reflection.Typing module R = FStar.Reflection.V2 module L = FStar.List.Tot module T = FStar.Tactics.V2 open FStar.List.Tot open Pulse.Syntax open Pulse.Elaborate.Pure open Pulse.Typing module RU = Pulse.RuntimeUtils open Pulse.Reflection.Util

c: Pulse.Syntax.Base.comp_st -> frame: Pulse.Syntax.Base.term -> e: FStar.Stubs.Reflection.Types.term -> FStar.Stubs.Reflection.Types.term

Prims.Tot

let elab_frame (c: comp_st) (frame: term) (e: R.term) =

let u = comp_u c in let ty = elab_term (comp_res c) in let pre = elab_term (comp_pre c) in let post = elab_term (comp_post c) in if C_ST? c then mk_frame_stt u ty pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e else if C_STAtomic? c then let opened = elab_term (comp_inames c) in mk_frame_stt_atomic u ty opened pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e else mk_frame_stt_ghost u ty pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e

Pulse.Elaborate.Core.fst

Pulse.Elaborate.Core.elab_bind

val elab_bind (#g #x #c1 #c2 #c: _) (bc: bind_comp g x c1 c2 c) (e1 e2: R.term) : R.term

val elab_bind (#g #x #c1 #c2 #c: _) (bc: bind_comp g x c1 c2 c) (e1 e2: R.term) : R.term

let elab_bind #g #x #c1 #c2 #c (bc:bind_comp g x c1 c2 c) (e1 e2:R.term) : R.term = let t1 = elab_term (comp_res c1) in let t2 = elab_term (comp_res c2) in match c1 with | C_ST _ -> mk_bind_stt (comp_u c1) (comp_u c2) t1 t2 (elab_term (comp_pre c1)) (mk_abs t1 R.Q_Explicit (elab_term (comp_post c1))) (mk_abs t2 R.Q_Explicit (elab_term (comp_post c2))) e1 e2 | C_STGhost _ -> mk_bind_ghost (comp_u c1) (comp_u c2) t1 t2 (elab_term (comp_pre c1)) (mk_abs t1 R.Q_Explicit (elab_term (comp_post c1))) (mk_abs t2 R.Q_Explicit (elab_term (comp_post c2))) e1 e2 | C_STAtomic inames obs1 _ -> let C_STAtomic _ obs2 _ = c2 in mk_bind_atomic (comp_u c1) (comp_u c2) (elab_observability obs1) (elab_observability obs2) (elab_term (comp_inames c1)) t1 t2 (elab_term (comp_pre c1)) (mk_abs t1 R.Q_Explicit (elab_term (comp_post c1))) (mk_abs t2 R.Q_Explicit (elab_term (comp_post c2))) e1 e2

(* 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.Elaborate.Core module RT = FStar.Reflection.Typing module R = FStar.Reflection.V2 module L = FStar.List.Tot module T = FStar.Tactics.V2 open FStar.List.Tot open Pulse.Syntax open Pulse.Elaborate.Pure open Pulse.Typing module RU = Pulse.RuntimeUtils open Pulse.Reflection.Util let elab_frame (c:comp_st) (frame:term) (e:R.term) = let u = comp_u c in let ty = elab_term (comp_res c) in let pre = elab_term (comp_pre c) in let post = elab_term (comp_post c) in if C_ST? c then mk_frame_stt u ty pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e else if C_STAtomic? c then let opened = elab_term (comp_inames c) in mk_frame_stt_atomic u ty opened pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e else mk_frame_stt_ghost u ty pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e let elab_sub (c1 c2:comp_st) (e:R.term) = let ty = elab_term (comp_res c1) in let u = comp_u c1 in let pre1 = elab_term (comp_pre c1) in let pre2 = elab_term (comp_pre c2) in let post1 = mk_abs ty R.Q_Explicit (elab_term (comp_post c1)) in let post2 = mk_abs ty R.Q_Explicit (elab_term (comp_post c2)) in if C_ST? c1 then mk_sub_stt u ty pre1 pre2 post1 post2 e else if C_STAtomic? c1 then let opened = elab_term (comp_inames c1) in mk_sub_stt_atomic u ty opened pre1 pre2 post1 post2 e else mk_sub_stt_ghost u ty pre1 pre2 post1 post2 e

bc: Pulse.Typing.bind_comp g x c1 c2 c -> e1: FStar.Stubs.Reflection.Types.term -> e2: FStar.Stubs.Reflection.Types.term -> FStar.Stubs.Reflection.Types.term

Prims.Tot

let elab_bind #g #x #c1 #c2 #c (bc: bind_comp g x c1 c2 c) (e1: R.term) (e2: R.term) : R.term =

let t1 = elab_term (comp_res c1) in let t2 = elab_term (comp_res c2) in match c1 with | C_ST _ -> mk_bind_stt (comp_u c1) (comp_u c2) t1 t2 (elab_term (comp_pre c1)) (mk_abs t1 R.Q_Explicit (elab_term (comp_post c1))) (mk_abs t2 R.Q_Explicit (elab_term (comp_post c2))) e1 e2 | C_STGhost _ -> mk_bind_ghost (comp_u c1) (comp_u c2) t1 t2 (elab_term (comp_pre c1)) (mk_abs t1 R.Q_Explicit (elab_term (comp_post c1))) (mk_abs t2 R.Q_Explicit (elab_term (comp_post c2))) e1 e2 | C_STAtomic inames obs1 _ -> let C_STAtomic _ obs2 _ = c2 in mk_bind_atomic (comp_u c1) (comp_u c2) (elab_observability obs1) (elab_observability obs2) (elab_term (comp_inames c1)) t1 t2 (elab_term (comp_pre c1)) (mk_abs t1 R.Q_Explicit (elab_term (comp_post c1))) (mk_abs t2 R.Q_Explicit (elab_term (comp_post c2))) e1 e2

Pulse.Elaborate.Core.fst

Pulse.Elaborate.Core.elab_lift

val elab_lift (#g #c1 #c2: _) (d: lift_comp g c1 c2) (e: R.term) : Tot R.term

val elab_lift (#g #c1 #c2: _) (d: lift_comp g c1 c2) (e: R.term) : Tot R.term

let elab_lift #g #c1 #c2 (d:lift_comp g c1 c2) (e:R.term) : Tot R.term = match d with | Lift_STAtomic_ST _ _ -> let t = elab_term (comp_res c1) in mk_lift_atomic_stt (comp_u c1) (elab_term (comp_res c1)) t (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e | Lift_Observability _ c o2 -> let t = elab_term (comp_res c1) in mk_lift_observability (comp_u c1) (elab_observability (C_STAtomic?.obs c)) (elab_observability o2) (elab_term (comp_inames c1)) t (elab_term (comp_pre c1)) (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e | Lift_Ghost_Neutral _ _ (| reveal_a, reveal_a_typing |) -> let t = elab_term (comp_res c1) in mk_lift_ghost_neutral (comp_u c1) t (elab_term (comp_pre c1)) (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e (elab_term reveal_a) | Lift_Neutral_Ghost _ c -> let t = elab_term (comp_res c1) in mk_lift_neutral_ghost (comp_u c1) t (elab_term (comp_pre c1)) (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e

(* 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.Elaborate.Core module RT = FStar.Reflection.Typing module R = FStar.Reflection.V2 module L = FStar.List.Tot module T = FStar.Tactics.V2 open FStar.List.Tot open Pulse.Syntax open Pulse.Elaborate.Pure open Pulse.Typing module RU = Pulse.RuntimeUtils open Pulse.Reflection.Util let elab_frame (c:comp_st) (frame:term) (e:R.term) = let u = comp_u c in let ty = elab_term (comp_res c) in let pre = elab_term (comp_pre c) in let post = elab_term (comp_post c) in if C_ST? c then mk_frame_stt u ty pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e else if C_STAtomic? c then let opened = elab_term (comp_inames c) in mk_frame_stt_atomic u ty opened pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e else mk_frame_stt_ghost u ty pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e let elab_sub (c1 c2:comp_st) (e:R.term) = let ty = elab_term (comp_res c1) in let u = comp_u c1 in let pre1 = elab_term (comp_pre c1) in let pre2 = elab_term (comp_pre c2) in let post1 = mk_abs ty R.Q_Explicit (elab_term (comp_post c1)) in let post2 = mk_abs ty R.Q_Explicit (elab_term (comp_post c2)) in if C_ST? c1 then mk_sub_stt u ty pre1 pre2 post1 post2 e else if C_STAtomic? c1 then let opened = elab_term (comp_inames c1) in mk_sub_stt_atomic u ty opened pre1 pre2 post1 post2 e else mk_sub_stt_ghost u ty pre1 pre2 post1 post2 e let elab_bind #g #x #c1 #c2 #c (bc:bind_comp g x c1 c2 c) (e1 e2:R.term) : R.term = let t1 = elab_term (comp_res c1) in let t2 = elab_term (comp_res c2) in match c1 with | C_ST _ -> mk_bind_stt (comp_u c1) (comp_u c2) t1 t2 (elab_term (comp_pre c1)) (mk_abs t1 R.Q_Explicit (elab_term (comp_post c1))) (mk_abs t2 R.Q_Explicit (elab_term (comp_post c2))) e1 e2 | C_STGhost _ -> mk_bind_ghost (comp_u c1) (comp_u c2) t1 t2 (elab_term (comp_pre c1)) (mk_abs t1 R.Q_Explicit (elab_term (comp_post c1))) (mk_abs t2 R.Q_Explicit (elab_term (comp_post c2))) e1 e2 | C_STAtomic inames obs1 _ -> let C_STAtomic _ obs2 _ = c2 in mk_bind_atomic (comp_u c1) (comp_u c2) (elab_observability obs1) (elab_observability obs2) (elab_term (comp_inames c1)) t1 t2 (elab_term (comp_pre c1)) (mk_abs t1 R.Q_Explicit (elab_term (comp_post c1))) (mk_abs t2 R.Q_Explicit (elab_term (comp_post c2))) e1 e2

d: Pulse.Typing.lift_comp g c1 c2 -> e: FStar.Stubs.Reflection.Types.term -> FStar.Stubs.Reflection.Types.term

Prims.Tot

let elab_lift #g #c1 #c2 (d: lift_comp g c1 c2) (e: R.term) : Tot R.term =

match d with | Lift_STAtomic_ST _ _ -> let t = elab_term (comp_res c1) in mk_lift_atomic_stt (comp_u c1) (elab_term (comp_res c1)) t (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e | Lift_Observability _ c o2 -> let t = elab_term (comp_res c1) in mk_lift_observability (comp_u c1) (elab_observability (C_STAtomic?.obs c)) (elab_observability o2) (elab_term (comp_inames c1)) t (elab_term (comp_pre c1)) (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e | Lift_Ghost_Neutral _ _ (| reveal_a , reveal_a_typing |) -> let t = elab_term (comp_res c1) in mk_lift_ghost_neutral (comp_u c1) t (elab_term (comp_pre c1)) (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e (elab_term reveal_a) | Lift_Neutral_Ghost _ c -> let t = elab_term (comp_res c1) in mk_lift_neutral_ghost (comp_u c1) t (elab_term (comp_pre c1)) (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e

Pulse.Elaborate.Core.fst

Pulse.Elaborate.Core.simple_arr

val simple_arr (t1 t2: R.term) : R.term

val simple_arr (t1 t2: R.term) : R.term

let simple_arr (t1 t2 : R.term) : R.term = let b = R.pack_binder { sort = t1; ppname = Sealed.seal "x"; qual = R.Q_Explicit; attrs = [] } in R.pack_ln (R.Tv_Arrow b (R.pack_comp (R.C_Total t2)))

(* 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.Elaborate.Core module RT = FStar.Reflection.Typing module R = FStar.Reflection.V2 module L = FStar.List.Tot module T = FStar.Tactics.V2 open FStar.List.Tot open Pulse.Syntax open Pulse.Elaborate.Pure open Pulse.Typing module RU = Pulse.RuntimeUtils open Pulse.Reflection.Util let elab_frame (c:comp_st) (frame:term) (e:R.term) = let u = comp_u c in let ty = elab_term (comp_res c) in let pre = elab_term (comp_pre c) in let post = elab_term (comp_post c) in if C_ST? c then mk_frame_stt u ty pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e else if C_STAtomic? c then let opened = elab_term (comp_inames c) in mk_frame_stt_atomic u ty opened pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e else mk_frame_stt_ghost u ty pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e let elab_sub (c1 c2:comp_st) (e:R.term) = let ty = elab_term (comp_res c1) in let u = comp_u c1 in let pre1 = elab_term (comp_pre c1) in let pre2 = elab_term (comp_pre c2) in let post1 = mk_abs ty R.Q_Explicit (elab_term (comp_post c1)) in let post2 = mk_abs ty R.Q_Explicit (elab_term (comp_post c2)) in if C_ST? c1 then mk_sub_stt u ty pre1 pre2 post1 post2 e else if C_STAtomic? c1 then let opened = elab_term (comp_inames c1) in mk_sub_stt_atomic u ty opened pre1 pre2 post1 post2 e else mk_sub_stt_ghost u ty pre1 pre2 post1 post2 e let elab_bind #g #x #c1 #c2 #c (bc:bind_comp g x c1 c2 c) (e1 e2:R.term) : R.term = let t1 = elab_term (comp_res c1) in let t2 = elab_term (comp_res c2) in match c1 with | C_ST _ -> mk_bind_stt (comp_u c1) (comp_u c2) t1 t2 (elab_term (comp_pre c1)) (mk_abs t1 R.Q_Explicit (elab_term (comp_post c1))) (mk_abs t2 R.Q_Explicit (elab_term (comp_post c2))) e1 e2 | C_STGhost _ -> mk_bind_ghost (comp_u c1) (comp_u c2) t1 t2 (elab_term (comp_pre c1)) (mk_abs t1 R.Q_Explicit (elab_term (comp_post c1))) (mk_abs t2 R.Q_Explicit (elab_term (comp_post c2))) e1 e2 | C_STAtomic inames obs1 _ -> let C_STAtomic _ obs2 _ = c2 in mk_bind_atomic (comp_u c1) (comp_u c2) (elab_observability obs1) (elab_observability obs2) (elab_term (comp_inames c1)) t1 t2 (elab_term (comp_pre c1)) (mk_abs t1 R.Q_Explicit (elab_term (comp_post c1))) (mk_abs t2 R.Q_Explicit (elab_term (comp_post c2))) e1 e2 let elab_lift #g #c1 #c2 (d:lift_comp g c1 c2) (e:R.term) : Tot R.term = match d with | Lift_STAtomic_ST _ _ -> let t = elab_term (comp_res c1) in mk_lift_atomic_stt (comp_u c1) (elab_term (comp_res c1)) t (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e | Lift_Observability _ c o2 -> let t = elab_term (comp_res c1) in mk_lift_observability (comp_u c1) (elab_observability (C_STAtomic?.obs c)) (elab_observability o2) (elab_term (comp_inames c1)) t (elab_term (comp_pre c1)) (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e | Lift_Ghost_Neutral _ _ (| reveal_a, reveal_a_typing |) -> let t = elab_term (comp_res c1) in mk_lift_ghost_neutral (comp_u c1) t (elab_term (comp_pre c1)) (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e (elab_term reveal_a) | Lift_Neutral_Ghost _ c -> let t = elab_term (comp_res c1) in mk_lift_neutral_ghost (comp_u c1) t (elab_term (comp_pre c1)) (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e let intro_pure_tm (p:term) = let open Pulse.Reflection.Util in wtag (Some STT_Ghost) (Tm_STApp { head = tm_pureapp (tm_fvar (as_fv (mk_pulse_lib_core_lid "intro_pure"))) None p; arg_qual = None; arg = tm_fstar (`()) Range.range_0 })

t1: FStar.Stubs.Reflection.Types.term -> t2: FStar.Stubs.Reflection.Types.term -> FStar.Stubs.Reflection.Types.term

Prims.Tot

let simple_arr (t1 t2: R.term) : R.term =

let b = R.pack_binder ({ sort = t1; ppname = Sealed.seal "x"; qual = R.Q_Explicit; attrs = [] }) in R.pack_ln (R.Tv_Arrow b (R.pack_comp (R.C_Total t2)))

Vale.Stdcalls.X64.Aes.fst

Vale.Stdcalls.X64.Aes.lowstar_key128

val lowstar_key128:lowstar_key128_t

val lowstar_key128:lowstar_key128_t

let lowstar_key128 : lowstar_key128_t = assert_norm (List.length dom + List.length ([]<:list arg) <= 4); IX64.wrap_weak_stdcall code_key128 dom (W.mk_prediction code_key128 dom [] (key128_lemma code_key128 IA.win))

module Vale.Stdcalls.X64.Aes open FStar.Mul open FStar.HyperStack.ST module HS = FStar.HyperStack module B = LowStar.Buffer module DV = LowStar.BufferView.Down module UV = LowStar.BufferView.Up open Vale.Def.Types_s open Vale.Interop.Base module IX64 = Vale.Interop.X64 module VSig = Vale.AsLowStar.ValeSig module LSig = Vale.AsLowStar.LowStarSig module ME = Vale.X64.Memory module V = Vale.X64.Decls module IA = Vale.Interop.Assumptions module W = Vale.AsLowStar.Wrapper open Vale.X64.MemoryAdapters module VS = Vale.X64.State module MS = Vale.X64.Machine_s

Vale.Stdcalls.X64.Aes.lowstar_key128_t

Prims.Tot

let lowstar_key128:lowstar_key128_t =

assert_norm (List.length dom + List.length ([] <: list arg) <= 4); IX64.wrap_weak_stdcall code_key128 dom (W.mk_prediction code_key128 dom [] (key128_lemma code_key128 IA.win))

Pulse.Elaborate.Core.fst

Pulse.Elaborate.Core.elab_sub

val elab_sub : c1: Pulse.Syntax.Base.comp_st -> c2: Pulse.Syntax.Base.comp_st -> e: FStar.Stubs.Reflection.Types.term -> FStar.Stubs.Reflection.Types.term

let elab_sub (c1 c2:comp_st) (e:R.term) = let ty = elab_term (comp_res c1) in let u = comp_u c1 in let pre1 = elab_term (comp_pre c1) in let pre2 = elab_term (comp_pre c2) in let post1 = mk_abs ty R.Q_Explicit (elab_term (comp_post c1)) in let post2 = mk_abs ty R.Q_Explicit (elab_term (comp_post c2)) in if C_ST? c1 then mk_sub_stt u ty pre1 pre2 post1 post2 e else if C_STAtomic? c1 then let opened = elab_term (comp_inames c1) in mk_sub_stt_atomic u ty opened pre1 pre2 post1 post2 e else mk_sub_stt_ghost u ty pre1 pre2 post1 post2 e

(* 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.Elaborate.Core module RT = FStar.Reflection.Typing module R = FStar.Reflection.V2 module L = FStar.List.Tot module T = FStar.Tactics.V2 open FStar.List.Tot open Pulse.Syntax open Pulse.Elaborate.Pure open Pulse.Typing module RU = Pulse.RuntimeUtils open Pulse.Reflection.Util let elab_frame (c:comp_st) (frame:term) (e:R.term) = let u = comp_u c in let ty = elab_term (comp_res c) in let pre = elab_term (comp_pre c) in let post = elab_term (comp_post c) in if C_ST? c then mk_frame_stt u ty pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e else if C_STAtomic? c then let opened = elab_term (comp_inames c) in mk_frame_stt_atomic u ty opened pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e else mk_frame_stt_ghost u ty pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e

c1: Pulse.Syntax.Base.comp_st -> c2: Pulse.Syntax.Base.comp_st -> e: FStar.Stubs.Reflection.Types.term -> FStar.Stubs.Reflection.Types.term

Prims.Tot

let elab_sub (c1 c2: comp_st) (e: R.term) =

let ty = elab_term (comp_res c1) in let u = comp_u c1 in let pre1 = elab_term (comp_pre c1) in let pre2 = elab_term (comp_pre c2) in let post1 = mk_abs ty R.Q_Explicit (elab_term (comp_post c1)) in let post2 = mk_abs ty R.Q_Explicit (elab_term (comp_post c2)) in if C_ST? c1 then mk_sub_stt u ty pre1 pre2 post1 post2 e else if C_STAtomic? c1 then let opened = elab_term (comp_inames c1) in mk_sub_stt_atomic u ty opened pre1 pre2 post1 post2 e else mk_sub_stt_ghost u ty pre1 pre2 post1 post2 e

IfcRulesReify.fst

IfcRulesReify.inv_com'

val inv_com' (env: label_fun) (c: com) (l: label) (h0: heap) : Tot Type0

val inv_com' (env: label_fun) (c: com) (l: label) (h0: heap) : Tot Type0

let inv_com' (env:label_fun) (c:com) (l:label) (h0:heap) : Tot Type0 = match interpret_com h0 c with | None -> True | Some h1 -> forall (i:id). (* {:pattern (env i < l)} *) env i < l ==> index h0 i = index h1 i

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module IfcRulesReify open Rel open WhileReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreExcFixed open FStar.Squash open FStar.Classical (****************************** Preliminaries ******************************) (* CH: Everything specialized to 2-point lattice *) type label = | Low | High val op_Less : label -> label -> Tot bool let op_Less l1 l2 = match l1, l2 with | Low,High -> true | _, _ -> false val op_Less_Equals : label -> label -> Tot bool let op_Less_Equals l1 l2 = match l1, l2 with | High,Low -> false | _, _ -> true val join : label -> label -> Tot label let join l1 l2 = match l1, l2 with | Low,Low -> Low | _, _ -> High val meet : label -> label -> Tot label let meet l1 l2 = match l1, l2 with | High, High -> High | _, _ -> Low let universal_property_meet l l1 l2 : Lemma (requires (l <= l1 /\ l <= l2)) (ensures (l <= meet l1 l2)) = () type label_fun = id -> Tot label type low_equiv (env:label_fun) (h1:rel heap) = (forall (x:id). (* {:pattern (env x)} *) env x = Low ==> index (R?.l h1) x = index (R?.r h1) x) (**************************** Typing Judgements ****************************) (* env |- e : l - Expressions do not modify the heap - Correctness - Low equivalent input heaps + Low label ==> same result *) let ni_exp (env:label_fun) (e:exp) (l:label) : Tot Type0 = forall (h: rel heap). (* {:pattern (low_equiv env h)} *) (low_equiv env h /\ Low? l) ==> (* interpret_exp (R?.r h) e = interpret_exp (R?.l h) e *) begin let vr = reify (interpret_exp_st e) (R?.r h)in let vl = reify (interpret_exp_st e) (R?.l h) in vr = vl end (* env,pc:l |- c - References with a label below l are not modified - Total correctness - Low equivalent input heaps ==> Low equivalent output heaps

env: IfcRulesReify.label_fun -> c: WhileReify.com -> l: IfcRulesReify.label -> h0: FStar.DM4F.Heap.IntStoreFixed.heap -> Type0

Prims.Tot

let inv_com' (env: label_fun) (c: com) (l: label) (h0: heap) : Tot Type0 =

match interpret_com h0 c with | None -> True | Some h1 -> forall (i: id). env i < l ==> index h0 i = index h1 i

Pulse.Elaborate.Core.fst

Pulse.Elaborate.Core.intro_pure_tm

val intro_pure_tm : p: Pulse.Syntax.Base.term -> Pulse.Syntax.Base.st_term

let intro_pure_tm (p:term) = let open Pulse.Reflection.Util in wtag (Some STT_Ghost) (Tm_STApp { head = tm_pureapp (tm_fvar (as_fv (mk_pulse_lib_core_lid "intro_pure"))) None p; arg_qual = None; arg = tm_fstar (`()) Range.range_0 })

(* 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.Elaborate.Core module RT = FStar.Reflection.Typing module R = FStar.Reflection.V2 module L = FStar.List.Tot module T = FStar.Tactics.V2 open FStar.List.Tot open Pulse.Syntax open Pulse.Elaborate.Pure open Pulse.Typing module RU = Pulse.RuntimeUtils open Pulse.Reflection.Util let elab_frame (c:comp_st) (frame:term) (e:R.term) = let u = comp_u c in let ty = elab_term (comp_res c) in let pre = elab_term (comp_pre c) in let post = elab_term (comp_post c) in if C_ST? c then mk_frame_stt u ty pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e else if C_STAtomic? c then let opened = elab_term (comp_inames c) in mk_frame_stt_atomic u ty opened pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e else mk_frame_stt_ghost u ty pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e let elab_sub (c1 c2:comp_st) (e:R.term) = let ty = elab_term (comp_res c1) in let u = comp_u c1 in let pre1 = elab_term (comp_pre c1) in let pre2 = elab_term (comp_pre c2) in let post1 = mk_abs ty R.Q_Explicit (elab_term (comp_post c1)) in let post2 = mk_abs ty R.Q_Explicit (elab_term (comp_post c2)) in if C_ST? c1 then mk_sub_stt u ty pre1 pre2 post1 post2 e else if C_STAtomic? c1 then let opened = elab_term (comp_inames c1) in mk_sub_stt_atomic u ty opened pre1 pre2 post1 post2 e else mk_sub_stt_ghost u ty pre1 pre2 post1 post2 e let elab_bind #g #x #c1 #c2 #c (bc:bind_comp g x c1 c2 c) (e1 e2:R.term) : R.term = let t1 = elab_term (comp_res c1) in let t2 = elab_term (comp_res c2) in match c1 with | C_ST _ -> mk_bind_stt (comp_u c1) (comp_u c2) t1 t2 (elab_term (comp_pre c1)) (mk_abs t1 R.Q_Explicit (elab_term (comp_post c1))) (mk_abs t2 R.Q_Explicit (elab_term (comp_post c2))) e1 e2 | C_STGhost _ -> mk_bind_ghost (comp_u c1) (comp_u c2) t1 t2 (elab_term (comp_pre c1)) (mk_abs t1 R.Q_Explicit (elab_term (comp_post c1))) (mk_abs t2 R.Q_Explicit (elab_term (comp_post c2))) e1 e2 | C_STAtomic inames obs1 _ -> let C_STAtomic _ obs2 _ = c2 in mk_bind_atomic (comp_u c1) (comp_u c2) (elab_observability obs1) (elab_observability obs2) (elab_term (comp_inames c1)) t1 t2 (elab_term (comp_pre c1)) (mk_abs t1 R.Q_Explicit (elab_term (comp_post c1))) (mk_abs t2 R.Q_Explicit (elab_term (comp_post c2))) e1 e2 let elab_lift #g #c1 #c2 (d:lift_comp g c1 c2) (e:R.term) : Tot R.term = match d with | Lift_STAtomic_ST _ _ -> let t = elab_term (comp_res c1) in mk_lift_atomic_stt (comp_u c1) (elab_term (comp_res c1)) t (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e | Lift_Observability _ c o2 -> let t = elab_term (comp_res c1) in mk_lift_observability (comp_u c1) (elab_observability (C_STAtomic?.obs c)) (elab_observability o2) (elab_term (comp_inames c1)) t (elab_term (comp_pre c1)) (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e | Lift_Ghost_Neutral _ _ (| reveal_a, reveal_a_typing |) -> let t = elab_term (comp_res c1) in mk_lift_ghost_neutral (comp_u c1) t (elab_term (comp_pre c1)) (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e (elab_term reveal_a) | Lift_Neutral_Ghost _ c -> let t = elab_term (comp_res c1) in mk_lift_neutral_ghost (comp_u c1) t (elab_term (comp_pre c1)) (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e

p: Pulse.Syntax.Base.term -> Pulse.Syntax.Base.st_term

Prims.Tot

let intro_pure_tm (p: term) =

let open Pulse.Reflection.Util in wtag (Some STT_Ghost) (Tm_STApp ({ head = tm_pureapp (tm_fvar (as_fv (mk_pulse_lib_core_lid "intro_pure"))) None p; arg_qual = None; arg = tm_fstar (`()) Range.range_0 }))

IfcRulesReify.fst

IfcRulesReify.assign_inv_com'

val assign_inv_com' (env: label_fun) (e: exp) (r: id) (h0: heap) : Lemma (inv_com' env (Assign r e) (env r) h0)

val assign_inv_com' (env: label_fun) (e: exp) (r: id) (h0: heap) : Lemma (inv_com' env (Assign r e) (env r) h0)

let assign_inv_com' (env:label_fun) (e:exp) (r:id) (h0:heap) : Lemma (inv_com' env (Assign r e) (env r) h0) = let v = reify (interpret_exp_st e) h0 in match reify (interpret_com_st (Assign r e) h0) h0 with | None, h1 -> () | Some (), h1 -> assert (h1 == upd h0 r v)

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module IfcRulesReify open Rel open WhileReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreExcFixed open FStar.Squash open FStar.Classical (****************************** Preliminaries ******************************) (* CH: Everything specialized to 2-point lattice *) type label = | Low | High val op_Less : label -> label -> Tot bool let op_Less l1 l2 = match l1, l2 with | Low,High -> true | _, _ -> false val op_Less_Equals : label -> label -> Tot bool let op_Less_Equals l1 l2 = match l1, l2 with | High,Low -> false | _, _ -> true val join : label -> label -> Tot label let join l1 l2 = match l1, l2 with | Low,Low -> Low | _, _ -> High val meet : label -> label -> Tot label let meet l1 l2 = match l1, l2 with | High, High -> High | _, _ -> Low let universal_property_meet l l1 l2 : Lemma (requires (l <= l1 /\ l <= l2)) (ensures (l <= meet l1 l2)) = () type label_fun = id -> Tot label type low_equiv (env:label_fun) (h1:rel heap) = (forall (x:id). (* {:pattern (env x)} *) env x = Low ==> index (R?.l h1) x = index (R?.r h1) x) (**************************** Typing Judgements ****************************) (* env |- e : l - Expressions do not modify the heap - Correctness - Low equivalent input heaps + Low label ==> same result *) let ni_exp (env:label_fun) (e:exp) (l:label) : Tot Type0 = forall (h: rel heap). (* {:pattern (low_equiv env h)} *) (low_equiv env h /\ Low? l) ==> (* interpret_exp (R?.r h) e = interpret_exp (R?.l h) e *) begin let vr = reify (interpret_exp_st e) (R?.r h)in let vl = reify (interpret_exp_st e) (R?.l h) in vr = vl end (* env,pc:l |- c - References with a label below l are not modified - Total correctness - Low equivalent input heaps ==> Low equivalent output heaps *) let inv_com' (env:label_fun) (c:com) (l:label) (h0:heap) : Tot Type0 = match interpret_com h0 c with | None -> True | Some h1 -> forall (i:id). (* {:pattern (env i < l)} *) env i < l ==> index h0 i = index h1 i let ni_com' (env:label_fun) (c:com) (l:label) (h0:rel heap) : Tot Type0 = let R h0l h0r = h0 in (* KM : That's the code that we would like to write but subtyping and matching on pairs interplay badly *) (* it generates a VC which boils down to [forall (h1l:heap). length h1l = length h0l] which is obviously false *) (* begin match interpret_com h0l c, interpret_com h0r c with *) (* | Some h1l, Some h1r -> low_equiv env (R h0l h0r) ==> low_equiv env (R h1l h1r) *) (* | _ -> True *) (* end *) begin match interpret_com h0l c with | Some h1l -> begin match interpret_com h0r c with | Some h1r -> low_equiv env h0 ==> low_equiv env (R h1l h1r) | _ -> True end | _ -> True end let ni_com (env:label_fun) (c:com) (l:label) : Tot Type0 = (forall (h0: rel heap). (* {:pattern (low_equiv env h0)} *) ni_com' env c l h0) /\ (forall (h0:heap). (* {:pattern (Some? (interpret_com h0 c))} *) inv_com' env c l h0) (*********************** Typing Rules for Expressions **********************) (* CH: The way we derive these rules looks more like a semantically-justified program logic than a syntactic type system. Any connection to Dave Naumann and Anindya Banerjee's "relational logic"? (e.g. https://arxiv.org/abs/1611.08992) *) (* Subtyping rule for expression labels E |- e : l1 l1 <= l2 ---------------------- E |- e : l2 *) val sub_exp : env:label_fun -> e:exp -> l1:label -> l2:label -> Lemma (requires (l1 <= l2 /\ ni_exp env e l1)) (ensures (ni_exp env e l2)) let sub_exp _ _ _ _ = () (* Typing rule for dereferencing ---------------- E | - r : E(r) *) val avar_exp : env:label_fun -> r:id -> Lemma (ensures (ni_exp env (AVar r) (env r))) let avar_exp _ _ = () (* Typing rule for Int constants i : int ------- i : Low *) val aint_exp : env:label_fun -> i:int -> Lemma (requires True) (ensures (ni_exp env (AInt i) Low)) let aint_exp _ _ = () (* Typing rule for binary operators e1 : l e2 : l ---------------- e1 `op` e2 : l *) val binop_exp : env:label_fun -> op:binop -> e1:exp -> e2:exp -> l:label -> Lemma (requires (ni_exp env e1 l) /\ (ni_exp env e2 l)) (ensures (ni_exp env (AOp op e1 e2) l)) let binop_exp env op e1 e2 l = () (************************ Typing Rules for Commands ************************) (* Subtyping rule for commands env,pc:l1 |- c l2 <= l1 --------------------------- env,pc:l2 |- c *) val sub_com : env:label_fun -> c:com -> l1:label -> l2:label -> Lemma (requires (l2 <= l1 /\ ni_com env c l1 )) (ensures (ni_com env c l2 )) let sub_com _ _ _ _ = () (* Typing rule for assignment env |- e : env(r) ------------------------ env, pc:env(r) |- r := e - label of expression and context label have to be below label of r (first one to prevent explicit, second to prevent implicit flows) *) let assign_inv_com0 (env:label_fun) (e:exp) (r:id) (ne:squash(ni_exp env e (env r))) (h0:rel heap) : Lemma (ni_com' env (Assign r e) (env r) h0) = FStar.Squash.give_proof ne ; let vr = reify (interpret_exp_st e) (R?.r h0) in let vl = reify (interpret_exp_st e) (R?.l h0) in match reify (interpret_com_st (Assign r e) (R?.l h0)) (R?.l h0) with | Some (), h1l -> begin match reify (interpret_com_st (Assign r e) (R?.r h0)) (R?.r h0) with | Some (), h1r -> assert (h1l = upd (R?.l h0) r vl /\ h1r = upd (R?.r h0) r vr) | None, _ -> () end | None, _ -> ()

env: IfcRulesReify.label_fun -> e: WhileReify.exp -> r: FStar.DM4F.Heap.IntStoreFixed.id -> h0: FStar.DM4F.Heap.IntStoreFixed.heap -> FStar.Pervasives.Lemma (ensures IfcRulesReify.inv_com' env (WhileReify.Assign r e) (env r) h0)

FStar.Pervasives.Lemma

let assign_inv_com' (env: label_fun) (e: exp) (r: id) (h0: heap) : Lemma (inv_com' env (Assign r e) (env r) h0) =

let v = reify (interpret_exp_st e) h0 in match reify (interpret_com_st (Assign r e) h0) h0 with | None, h1 -> () | Some (), h1 -> assert (h1 == upd h0 r v)

IfcRulesReify.fst

IfcRulesReify.assign_com

val assign_com : env:label_fun -> e:exp -> r:id -> Lemma (requires (ni_exp env e (env r))) (ensures (ni_com env (Assign r e) (env r)))

val assign_com : env:label_fun -> e:exp -> r:id -> Lemma (requires (ni_exp env e (env r))) (ensures (ni_com env (Assign r e) (env r)))

let assign_com env e r = forall_intro (assign_inv_com0 env e r (FStar.Squash.get_proof (ni_exp env e (env r)))) ; forall_intro (assign_inv_com' env e r)

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module IfcRulesReify open Rel open WhileReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreExcFixed open FStar.Squash open FStar.Classical (****************************** Preliminaries ******************************) (* CH: Everything specialized to 2-point lattice *) type label = | Low | High val op_Less : label -> label -> Tot bool let op_Less l1 l2 = match l1, l2 with | Low,High -> true | _, _ -> false val op_Less_Equals : label -> label -> Tot bool let op_Less_Equals l1 l2 = match l1, l2 with | High,Low -> false | _, _ -> true val join : label -> label -> Tot label let join l1 l2 = match l1, l2 with | Low,Low -> Low | _, _ -> High val meet : label -> label -> Tot label let meet l1 l2 = match l1, l2 with | High, High -> High | _, _ -> Low let universal_property_meet l l1 l2 : Lemma (requires (l <= l1 /\ l <= l2)) (ensures (l <= meet l1 l2)) = () type label_fun = id -> Tot label type low_equiv (env:label_fun) (h1:rel heap) = (forall (x:id). (* {:pattern (env x)} *) env x = Low ==> index (R?.l h1) x = index (R?.r h1) x) (**************************** Typing Judgements ****************************) (* env |- e : l - Expressions do not modify the heap - Correctness - Low equivalent input heaps + Low label ==> same result *) let ni_exp (env:label_fun) (e:exp) (l:label) : Tot Type0 = forall (h: rel heap). (* {:pattern (low_equiv env h)} *) (low_equiv env h /\ Low? l) ==> (* interpret_exp (R?.r h) e = interpret_exp (R?.l h) e *) begin let vr = reify (interpret_exp_st e) (R?.r h)in let vl = reify (interpret_exp_st e) (R?.l h) in vr = vl end (* env,pc:l |- c - References with a label below l are not modified - Total correctness - Low equivalent input heaps ==> Low equivalent output heaps *) let inv_com' (env:label_fun) (c:com) (l:label) (h0:heap) : Tot Type0 = match interpret_com h0 c with | None -> True | Some h1 -> forall (i:id). (* {:pattern (env i < l)} *) env i < l ==> index h0 i = index h1 i let ni_com' (env:label_fun) (c:com) (l:label) (h0:rel heap) : Tot Type0 = let R h0l h0r = h0 in (* KM : That's the code that we would like to write but subtyping and matching on pairs interplay badly *) (* it generates a VC which boils down to [forall (h1l:heap). length h1l = length h0l] which is obviously false *) (* begin match interpret_com h0l c, interpret_com h0r c with *) (* | Some h1l, Some h1r -> low_equiv env (R h0l h0r) ==> low_equiv env (R h1l h1r) *) (* | _ -> True *) (* end *) begin match interpret_com h0l c with | Some h1l -> begin match interpret_com h0r c with | Some h1r -> low_equiv env h0 ==> low_equiv env (R h1l h1r) | _ -> True end | _ -> True end let ni_com (env:label_fun) (c:com) (l:label) : Tot Type0 = (forall (h0: rel heap). (* {:pattern (low_equiv env h0)} *) ni_com' env c l h0) /\ (forall (h0:heap). (* {:pattern (Some? (interpret_com h0 c))} *) inv_com' env c l h0) (*********************** Typing Rules for Expressions **********************) (* CH: The way we derive these rules looks more like a semantically-justified program logic than a syntactic type system. Any connection to Dave Naumann and Anindya Banerjee's "relational logic"? (e.g. https://arxiv.org/abs/1611.08992) *) (* Subtyping rule for expression labels E |- e : l1 l1 <= l2 ---------------------- E |- e : l2 *) val sub_exp : env:label_fun -> e:exp -> l1:label -> l2:label -> Lemma (requires (l1 <= l2 /\ ni_exp env e l1)) (ensures (ni_exp env e l2)) let sub_exp _ _ _ _ = () (* Typing rule for dereferencing ---------------- E | - r : E(r) *) val avar_exp : env:label_fun -> r:id -> Lemma (ensures (ni_exp env (AVar r) (env r))) let avar_exp _ _ = () (* Typing rule for Int constants i : int ------- i : Low *) val aint_exp : env:label_fun -> i:int -> Lemma (requires True) (ensures (ni_exp env (AInt i) Low)) let aint_exp _ _ = () (* Typing rule for binary operators e1 : l e2 : l ---------------- e1 `op` e2 : l *) val binop_exp : env:label_fun -> op:binop -> e1:exp -> e2:exp -> l:label -> Lemma (requires (ni_exp env e1 l) /\ (ni_exp env e2 l)) (ensures (ni_exp env (AOp op e1 e2) l)) let binop_exp env op e1 e2 l = () (************************ Typing Rules for Commands ************************) (* Subtyping rule for commands env,pc:l1 |- c l2 <= l1 --------------------------- env,pc:l2 |- c *) val sub_com : env:label_fun -> c:com -> l1:label -> l2:label -> Lemma (requires (l2 <= l1 /\ ni_com env c l1 )) (ensures (ni_com env c l2 )) let sub_com _ _ _ _ = () (* Typing rule for assignment env |- e : env(r) ------------------------ env, pc:env(r) |- r := e - label of expression and context label have to be below label of r (first one to prevent explicit, second to prevent implicit flows) *) let assign_inv_com0 (env:label_fun) (e:exp) (r:id) (ne:squash(ni_exp env e (env r))) (h0:rel heap) : Lemma (ni_com' env (Assign r e) (env r) h0) = FStar.Squash.give_proof ne ; let vr = reify (interpret_exp_st e) (R?.r h0) in let vl = reify (interpret_exp_st e) (R?.l h0) in match reify (interpret_com_st (Assign r e) (R?.l h0)) (R?.l h0) with | Some (), h1l -> begin match reify (interpret_com_st (Assign r e) (R?.r h0)) (R?.r h0) with | Some (), h1r -> assert (h1l = upd (R?.l h0) r vl /\ h1r = upd (R?.r h0) r vr) | None, _ -> () end | None, _ -> () let assign_inv_com' (env:label_fun) (e:exp) (r:id) (h0:heap) : Lemma (inv_com' env (Assign r e) (env r) h0) = let v = reify (interpret_exp_st e) h0 in match reify (interpret_com_st (Assign r e) h0) h0 with | None, h1 -> () | Some (), h1 -> assert (h1 == upd h0 r v) val assign_com : env:label_fun -> e:exp -> r:id -> Lemma (requires (ni_exp env e (env r)))

env: IfcRulesReify.label_fun -> e: WhileReify.exp -> r: FStar.DM4F.Heap.IntStoreFixed.id -> FStar.Pervasives.Lemma (requires IfcRulesReify.ni_exp env e (env r)) (ensures IfcRulesReify.ni_com env (WhileReify.Assign r e) (env r))

FStar.Pervasives.Lemma

let assign_com env e r =

forall_intro (assign_inv_com0 env e r (FStar.Squash.get_proof (ni_exp env e (env r)))); forall_intro (assign_inv_com' env e r)

IfcRulesReify.fst

IfcRulesReify.assign_inv_com0

val assign_inv_com0 (env: label_fun) (e: exp) (r: id) (ne: squash (ni_exp env e (env r))) (h0: rel heap) : Lemma (ni_com' env (Assign r e) (env r) h0)

val assign_inv_com0 (env: label_fun) (e: exp) (r: id) (ne: squash (ni_exp env e (env r))) (h0: rel heap) : Lemma (ni_com' env (Assign r e) (env r) h0)

let assign_inv_com0 (env:label_fun) (e:exp) (r:id) (ne:squash(ni_exp env e (env r))) (h0:rel heap) : Lemma (ni_com' env (Assign r e) (env r) h0) = FStar.Squash.give_proof ne ; let vr = reify (interpret_exp_st e) (R?.r h0) in let vl = reify (interpret_exp_st e) (R?.l h0) in match reify (interpret_com_st (Assign r e) (R?.l h0)) (R?.l h0) with | Some (), h1l -> begin match reify (interpret_com_st (Assign r e) (R?.r h0)) (R?.r h0) with | Some (), h1r -> assert (h1l = upd (R?.l h0) r vl /\ h1r = upd (R?.r h0) r vr) | None, _ -> () end | None, _ -> ()

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module IfcRulesReify open Rel open WhileReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreExcFixed open FStar.Squash open FStar.Classical (****************************** Preliminaries ******************************) (* CH: Everything specialized to 2-point lattice *) type label = | Low | High val op_Less : label -> label -> Tot bool let op_Less l1 l2 = match l1, l2 with | Low,High -> true | _, _ -> false val op_Less_Equals : label -> label -> Tot bool let op_Less_Equals l1 l2 = match l1, l2 with | High,Low -> false | _, _ -> true val join : label -> label -> Tot label let join l1 l2 = match l1, l2 with | Low,Low -> Low | _, _ -> High val meet : label -> label -> Tot label let meet l1 l2 = match l1, l2 with | High, High -> High | _, _ -> Low let universal_property_meet l l1 l2 : Lemma (requires (l <= l1 /\ l <= l2)) (ensures (l <= meet l1 l2)) = () type label_fun = id -> Tot label type low_equiv (env:label_fun) (h1:rel heap) = (forall (x:id). (* {:pattern (env x)} *) env x = Low ==> index (R?.l h1) x = index (R?.r h1) x) (**************************** Typing Judgements ****************************) (* env |- e : l - Expressions do not modify the heap - Correctness - Low equivalent input heaps + Low label ==> same result *) let ni_exp (env:label_fun) (e:exp) (l:label) : Tot Type0 = forall (h: rel heap). (* {:pattern (low_equiv env h)} *) (low_equiv env h /\ Low? l) ==> (* interpret_exp (R?.r h) e = interpret_exp (R?.l h) e *) begin let vr = reify (interpret_exp_st e) (R?.r h)in let vl = reify (interpret_exp_st e) (R?.l h) in vr = vl end (* env,pc:l |- c - References with a label below l are not modified - Total correctness - Low equivalent input heaps ==> Low equivalent output heaps *) let inv_com' (env:label_fun) (c:com) (l:label) (h0:heap) : Tot Type0 = match interpret_com h0 c with | None -> True | Some h1 -> forall (i:id). (* {:pattern (env i < l)} *) env i < l ==> index h0 i = index h1 i let ni_com' (env:label_fun) (c:com) (l:label) (h0:rel heap) : Tot Type0 = let R h0l h0r = h0 in (* KM : That's the code that we would like to write but subtyping and matching on pairs interplay badly *) (* it generates a VC which boils down to [forall (h1l:heap). length h1l = length h0l] which is obviously false *) (* begin match interpret_com h0l c, interpret_com h0r c with *) (* | Some h1l, Some h1r -> low_equiv env (R h0l h0r) ==> low_equiv env (R h1l h1r) *) (* | _ -> True *) (* end *) begin match interpret_com h0l c with | Some h1l -> begin match interpret_com h0r c with | Some h1r -> low_equiv env h0 ==> low_equiv env (R h1l h1r) | _ -> True end | _ -> True end let ni_com (env:label_fun) (c:com) (l:label) : Tot Type0 = (forall (h0: rel heap). (* {:pattern (low_equiv env h0)} *) ni_com' env c l h0) /\ (forall (h0:heap). (* {:pattern (Some? (interpret_com h0 c))} *) inv_com' env c l h0) (*********************** Typing Rules for Expressions **********************) (* CH: The way we derive these rules looks more like a semantically-justified program logic than a syntactic type system. Any connection to Dave Naumann and Anindya Banerjee's "relational logic"? (e.g. https://arxiv.org/abs/1611.08992) *) (* Subtyping rule for expression labels E |- e : l1 l1 <= l2 ---------------------- E |- e : l2 *) val sub_exp : env:label_fun -> e:exp -> l1:label -> l2:label -> Lemma (requires (l1 <= l2 /\ ni_exp env e l1)) (ensures (ni_exp env e l2)) let sub_exp _ _ _ _ = () (* Typing rule for dereferencing ---------------- E | - r : E(r) *) val avar_exp : env:label_fun -> r:id -> Lemma (ensures (ni_exp env (AVar r) (env r))) let avar_exp _ _ = () (* Typing rule for Int constants i : int ------- i : Low *) val aint_exp : env:label_fun -> i:int -> Lemma (requires True) (ensures (ni_exp env (AInt i) Low)) let aint_exp _ _ = () (* Typing rule for binary operators e1 : l e2 : l ---------------- e1 `op` e2 : l *) val binop_exp : env:label_fun -> op:binop -> e1:exp -> e2:exp -> l:label -> Lemma (requires (ni_exp env e1 l) /\ (ni_exp env e2 l)) (ensures (ni_exp env (AOp op e1 e2) l)) let binop_exp env op e1 e2 l = () (************************ Typing Rules for Commands ************************) (* Subtyping rule for commands env,pc:l1 |- c l2 <= l1 --------------------------- env,pc:l2 |- c *) val sub_com : env:label_fun -> c:com -> l1:label -> l2:label -> Lemma (requires (l2 <= l1 /\ ni_com env c l1 )) (ensures (ni_com env c l2 )) let sub_com _ _ _ _ = () (* Typing rule for assignment env |- e : env(r) ------------------------ env, pc:env(r) |- r := e - label of expression and context label have to be below label of r (first one to prevent explicit, second to prevent implicit flows) *)

env: IfcRulesReify.label_fun -> e: WhileReify.exp -> r: FStar.DM4F.Heap.IntStoreFixed.id -> ne: Prims.squash (IfcRulesReify.ni_exp env e (env r)) -> h0: Rel.rel FStar.DM4F.Heap.IntStoreFixed.heap -> FStar.Pervasives.Lemma (ensures IfcRulesReify.ni_com' env (WhileReify.Assign r e) (env r) h0)

FStar.Pervasives.Lemma

let assign_inv_com0 (env: label_fun) (e: exp) (r: id) (ne: squash (ni_exp env e (env r))) (h0: rel heap) : Lemma (ni_com' env (Assign r e) (env r) h0) =

FStar.Squash.give_proof ne; let vr = reify (interpret_exp_st e) (R?.r h0) in let vl = reify (interpret_exp_st e) (R?.l h0) in match reify (interpret_com_st (Assign r e) (R?.l h0)) (R?.l h0) with | Some (), h1l -> (match reify (interpret_com_st (Assign r e) (R?.r h0)) (R?.r h0) with | Some (), h1r -> assert (h1l = upd (R?.l h0) r vl /\ h1r = upd (R?.r h0) r vr) | None, _ -> ()) | None, _ -> ()

Vale.Stdcalls.X64.Aes.fst

Vale.Stdcalls.X64.Aes.lowstar_key256

val lowstar_key256:lowstar_key256_t

val lowstar_key256:lowstar_key256_t

let lowstar_key256 : lowstar_key256_t = assert_norm (List.length dom + List.length ([]<:list arg) <= 4); IX64.wrap_weak_stdcall code_key256 dom (W.mk_prediction code_key256 dom [] (key256_lemma code_key256 IA.win))

module Vale.Stdcalls.X64.Aes open FStar.Mul open FStar.HyperStack.ST module HS = FStar.HyperStack module B = LowStar.Buffer module DV = LowStar.BufferView.Down module UV = LowStar.BufferView.Up open Vale.Def.Types_s open Vale.Interop.Base module IX64 = Vale.Interop.X64 module VSig = Vale.AsLowStar.ValeSig module LSig = Vale.AsLowStar.LowStarSig module ME = Vale.X64.Memory module V = Vale.X64.Decls module IA = Vale.Interop.Assumptions module W = Vale.AsLowStar.Wrapper open Vale.X64.MemoryAdapters module VS = Vale.X64.State module MS = Vale.X64.Machine_s let lowstar_key128 : lowstar_key128_t = assert_norm (List.length dom + List.length ([]<:list arg) <= 4); IX64.wrap_weak_stdcall code_key128 dom (W.mk_prediction code_key128 dom [] (key128_lemma code_key128 IA.win)) let aes128_key_expansion //: normal lowstar_key128_t = as_normal_t #lowstar_key128_t lowstar_key128

Vale.Stdcalls.X64.Aes.lowstar_key256_t

Prims.Tot

let lowstar_key256:lowstar_key256_t =

assert_norm (List.length dom + List.length ([] <: list arg) <= 4); IX64.wrap_weak_stdcall code_key256 dom (W.mk_prediction code_key256 dom [] (key256_lemma code_key256 IA.win))

IfcRulesReify.fst

IfcRulesReify.seq_com

val seq_com : env:label_fun -> c1:com -> c2:com -> l:label -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (ni_com env (Seq c1 c2) l))

val seq_com : env:label_fun -> c1:com -> c2:com -> l:label -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (ni_com env (Seq c1 c2) l))

let seq_com env c1 c2 l = forall_intro (fun (h0:rel heap) -> seq_com' env c1 c2 l h0 <: Lemma (ni_com' env (Seq c1 c2) l h0)) ; forall_intro (fun (h0:heap) -> seq_inv_com' env c1 c2 l h0 <: Lemma (inv_com' env (Seq c1 c2) l h0))

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module IfcRulesReify open Rel open WhileReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreExcFixed open FStar.Squash open FStar.Classical (****************************** Preliminaries ******************************) (* CH: Everything specialized to 2-point lattice *) type label = | Low | High val op_Less : label -> label -> Tot bool let op_Less l1 l2 = match l1, l2 with | Low,High -> true | _, _ -> false val op_Less_Equals : label -> label -> Tot bool let op_Less_Equals l1 l2 = match l1, l2 with | High,Low -> false | _, _ -> true val join : label -> label -> Tot label let join l1 l2 = match l1, l2 with | Low,Low -> Low | _, _ -> High val meet : label -> label -> Tot label let meet l1 l2 = match l1, l2 with | High, High -> High | _, _ -> Low let universal_property_meet l l1 l2 : Lemma (requires (l <= l1 /\ l <= l2)) (ensures (l <= meet l1 l2)) = () type label_fun = id -> Tot label type low_equiv (env:label_fun) (h1:rel heap) = (forall (x:id). (* {:pattern (env x)} *) env x = Low ==> index (R?.l h1) x = index (R?.r h1) x) (**************************** Typing Judgements ****************************) (* env |- e : l - Expressions do not modify the heap - Correctness - Low equivalent input heaps + Low label ==> same result *) let ni_exp (env:label_fun) (e:exp) (l:label) : Tot Type0 = forall (h: rel heap). (* {:pattern (low_equiv env h)} *) (low_equiv env h /\ Low? l) ==> (* interpret_exp (R?.r h) e = interpret_exp (R?.l h) e *) begin let vr = reify (interpret_exp_st e) (R?.r h)in let vl = reify (interpret_exp_st e) (R?.l h) in vr = vl end (* env,pc:l |- c - References with a label below l are not modified - Total correctness - Low equivalent input heaps ==> Low equivalent output heaps *) let inv_com' (env:label_fun) (c:com) (l:label) (h0:heap) : Tot Type0 = match interpret_com h0 c with | None -> True | Some h1 -> forall (i:id). (* {:pattern (env i < l)} *) env i < l ==> index h0 i = index h1 i let ni_com' (env:label_fun) (c:com) (l:label) (h0:rel heap) : Tot Type0 = let R h0l h0r = h0 in (* KM : That's the code that we would like to write but subtyping and matching on pairs interplay badly *) (* it generates a VC which boils down to [forall (h1l:heap). length h1l = length h0l] which is obviously false *) (* begin match interpret_com h0l c, interpret_com h0r c with *) (* | Some h1l, Some h1r -> low_equiv env (R h0l h0r) ==> low_equiv env (R h1l h1r) *) (* | _ -> True *) (* end *) begin match interpret_com h0l c with | Some h1l -> begin match interpret_com h0r c with | Some h1r -> low_equiv env h0 ==> low_equiv env (R h1l h1r) | _ -> True end | _ -> True end let ni_com (env:label_fun) (c:com) (l:label) : Tot Type0 = (forall (h0: rel heap). (* {:pattern (low_equiv env h0)} *) ni_com' env c l h0) /\ (forall (h0:heap). (* {:pattern (Some? (interpret_com h0 c))} *) inv_com' env c l h0) (*********************** Typing Rules for Expressions **********************) (* CH: The way we derive these rules looks more like a semantically-justified program logic than a syntactic type system. Any connection to Dave Naumann and Anindya Banerjee's "relational logic"? (e.g. https://arxiv.org/abs/1611.08992) *) (* Subtyping rule for expression labels E |- e : l1 l1 <= l2 ---------------------- E |- e : l2 *) val sub_exp : env:label_fun -> e:exp -> l1:label -> l2:label -> Lemma (requires (l1 <= l2 /\ ni_exp env e l1)) (ensures (ni_exp env e l2)) let sub_exp _ _ _ _ = () (* Typing rule for dereferencing ---------------- E | - r : E(r) *) val avar_exp : env:label_fun -> r:id -> Lemma (ensures (ni_exp env (AVar r) (env r))) let avar_exp _ _ = () (* Typing rule for Int constants i : int ------- i : Low *) val aint_exp : env:label_fun -> i:int -> Lemma (requires True) (ensures (ni_exp env (AInt i) Low)) let aint_exp _ _ = () (* Typing rule for binary operators e1 : l e2 : l ---------------- e1 `op` e2 : l *) val binop_exp : env:label_fun -> op:binop -> e1:exp -> e2:exp -> l:label -> Lemma (requires (ni_exp env e1 l) /\ (ni_exp env e2 l)) (ensures (ni_exp env (AOp op e1 e2) l)) let binop_exp env op e1 e2 l = () (************************ Typing Rules for Commands ************************) (* Subtyping rule for commands env,pc:l1 |- c l2 <= l1 --------------------------- env,pc:l2 |- c *) val sub_com : env:label_fun -> c:com -> l1:label -> l2:label -> Lemma (requires (l2 <= l1 /\ ni_com env c l1 )) (ensures (ni_com env c l2 )) let sub_com _ _ _ _ = () (* Typing rule for assignment env |- e : env(r) ------------------------ env, pc:env(r) |- r := e - label of expression and context label have to be below label of r (first one to prevent explicit, second to prevent implicit flows) *) let assign_inv_com0 (env:label_fun) (e:exp) (r:id) (ne:squash(ni_exp env e (env r))) (h0:rel heap) : Lemma (ni_com' env (Assign r e) (env r) h0) = FStar.Squash.give_proof ne ; let vr = reify (interpret_exp_st e) (R?.r h0) in let vl = reify (interpret_exp_st e) (R?.l h0) in match reify (interpret_com_st (Assign r e) (R?.l h0)) (R?.l h0) with | Some (), h1l -> begin match reify (interpret_com_st (Assign r e) (R?.r h0)) (R?.r h0) with | Some (), h1r -> assert (h1l = upd (R?.l h0) r vl /\ h1r = upd (R?.r h0) r vr) | None, _ -> () end | None, _ -> () let assign_inv_com' (env:label_fun) (e:exp) (r:id) (h0:heap) : Lemma (inv_com' env (Assign r e) (env r) h0) = let v = reify (interpret_exp_st e) h0 in match reify (interpret_com_st (Assign r e) h0) h0 with | None, h1 -> () | Some (), h1 -> assert (h1 == upd h0 r v) val assign_com : env:label_fun -> e:exp -> r:id -> Lemma (requires (ni_exp env e (env r))) (ensures (ni_com env (Assign r e) (env r))) let assign_com env e r = forall_intro (assign_inv_com0 env e r (FStar.Squash.get_proof (ni_exp env e (env r)))) ; forall_intro (assign_inv_com' env e r) let seq_nil1 (c1:com) (c2:com) (h:heap) : Lemma (requires (fst (reify (interpret_com_st c1 h) h) = None)) (ensures (fst (reify (interpret_com_st (Seq c1 c2) h) h) = None)) = () let seq_nil2 (c1:com) (c2:com) (h0:heap) (h1:heap) : Lemma (requires (h1 == snd (reify (interpret_com_st c1 h0) h0) /\ fst (reify (interpret_com_st c2 h1) h1) = None)) (ensures (fst (reify (interpret_com_st (Seq c1 c2) h0) h0) = None)) = () (* Sequencing rule for commands env,pc:l |- c1 env,pc:l |- c2 ------------------------------ env,pc:l |- c1; c2 *) val seq_inv_com' : env:label_fun -> c1:com -> c2:com -> l:label -> h0:heap -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (inv_com' env (Seq c1 c2) l h0)) let seq_inv_com' env c1 c2 l h0 = match reify (interpret_com_st c1 h0) h0 with | None, _ -> seq_nil1 c1 c2 h0 | Some (), h1 -> match reify (interpret_com_st c2 h1) h1 with | None, _ -> seq_nil2 c1 c2 h0 h1 | Some (), h2 -> () #set-options "--z3rlimit 50" let use_ni_com (env:label_fun) (c:com) (l:label) (h:rel heap{low_equiv env h}) : Lemma (requires ni_com env c l) (ensures (let R hl hr = h in match reify (interpret_com_st c hl) hl, reify (interpret_com_st c hr) hr with | (Some _, hl'), (Some _, hr') -> low_equiv env (R hl' hr') | _ -> True)) = () val seq_com' : env:label_fun -> c1:com -> c2:com -> l:label -> h0: rel heap -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (ni_com' env (Seq c1 c2) l h0)) let seq_com' env c1 c2 l h0 = if not (FStar.StrongExcludedMiddle.strong_excluded_middle (low_equiv env h0)) then () else begin assert (low_equiv env h0); let R h0l h0r = h0 in match reify (interpret_com_st c1 h0l) h0l with | None, _ -> seq_nil1 c1 c2 h0l | Some (), h1l -> match reify (interpret_com_st c1 h0r) h0r with | None, _ -> seq_nil1 c1 c2 h0r | Some (), h1r -> match reify (interpret_com_st c2 h1l) h1l with | None, _ -> seq_nil2 c1 c2 h0l h1l | Some (), h2l -> match reify (interpret_com_st c2 h1r) h1r with | None, _ -> seq_nil2 c1 c2 h0r h1r | Some (), h2r -> let h1 = R h1l h1r in use_ni_com env c1 l h0; assert (low_equiv env h1) ; let h2 = R h2l h2r in use_ni_com env c2 l h1; assert (low_equiv env h2) end val seq_com : env:label_fun -> c1:com -> c2:com -> l:label -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l))

env: IfcRulesReify.label_fun -> c1: WhileReify.com -> c2: WhileReify.com -> l: IfcRulesReify.label -> FStar.Pervasives.Lemma (requires IfcRulesReify.ni_com env c1 l /\ IfcRulesReify.ni_com env c2 l) (ensures IfcRulesReify.ni_com env (WhileReify.Seq c1 c2) l)

FStar.Pervasives.Lemma

let seq_com env c1 c2 l =

forall_intro (fun (h0: rel heap) -> seq_com' env c1 c2 l h0 <: Lemma (ni_com' env (Seq c1 c2) l h0)); forall_intro (fun (h0: heap) -> seq_inv_com' env c1 c2 l h0 <: Lemma (inv_com' env (Seq c1 c2) l h0) )

IfcRulesReify.fst

IfcRulesReify.seq_inv_com'

val seq_inv_com' : env:label_fun -> c1:com -> c2:com -> l:label -> h0:heap -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (inv_com' env (Seq c1 c2) l h0))

val seq_inv_com' : env:label_fun -> c1:com -> c2:com -> l:label -> h0:heap -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (inv_com' env (Seq c1 c2) l h0))

let seq_inv_com' env c1 c2 l h0 = match reify (interpret_com_st c1 h0) h0 with | None, _ -> seq_nil1 c1 c2 h0 | Some (), h1 -> match reify (interpret_com_st c2 h1) h1 with | None, _ -> seq_nil2 c1 c2 h0 h1 | Some (), h2 -> ()

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module IfcRulesReify open Rel open WhileReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreExcFixed open FStar.Squash open FStar.Classical (****************************** Preliminaries ******************************) (* CH: Everything specialized to 2-point lattice *) type label = | Low | High val op_Less : label -> label -> Tot bool let op_Less l1 l2 = match l1, l2 with | Low,High -> true | _, _ -> false val op_Less_Equals : label -> label -> Tot bool let op_Less_Equals l1 l2 = match l1, l2 with | High,Low -> false | _, _ -> true val join : label -> label -> Tot label let join l1 l2 = match l1, l2 with | Low,Low -> Low | _, _ -> High val meet : label -> label -> Tot label let meet l1 l2 = match l1, l2 with | High, High -> High | _, _ -> Low let universal_property_meet l l1 l2 : Lemma (requires (l <= l1 /\ l <= l2)) (ensures (l <= meet l1 l2)) = () type label_fun = id -> Tot label type low_equiv (env:label_fun) (h1:rel heap) = (forall (x:id). (* {:pattern (env x)} *) env x = Low ==> index (R?.l h1) x = index (R?.r h1) x) (**************************** Typing Judgements ****************************) (* env |- e : l - Expressions do not modify the heap - Correctness - Low equivalent input heaps + Low label ==> same result *) let ni_exp (env:label_fun) (e:exp) (l:label) : Tot Type0 = forall (h: rel heap). (* {:pattern (low_equiv env h)} *) (low_equiv env h /\ Low? l) ==> (* interpret_exp (R?.r h) e = interpret_exp (R?.l h) e *) begin let vr = reify (interpret_exp_st e) (R?.r h)in let vl = reify (interpret_exp_st e) (R?.l h) in vr = vl end (* env,pc:l |- c - References with a label below l are not modified - Total correctness - Low equivalent input heaps ==> Low equivalent output heaps *) let inv_com' (env:label_fun) (c:com) (l:label) (h0:heap) : Tot Type0 = match interpret_com h0 c with | None -> True | Some h1 -> forall (i:id). (* {:pattern (env i < l)} *) env i < l ==> index h0 i = index h1 i let ni_com' (env:label_fun) (c:com) (l:label) (h0:rel heap) : Tot Type0 = let R h0l h0r = h0 in (* KM : That's the code that we would like to write but subtyping and matching on pairs interplay badly *) (* it generates a VC which boils down to [forall (h1l:heap). length h1l = length h0l] which is obviously false *) (* begin match interpret_com h0l c, interpret_com h0r c with *) (* | Some h1l, Some h1r -> low_equiv env (R h0l h0r) ==> low_equiv env (R h1l h1r) *) (* | _ -> True *) (* end *) begin match interpret_com h0l c with | Some h1l -> begin match interpret_com h0r c with | Some h1r -> low_equiv env h0 ==> low_equiv env (R h1l h1r) | _ -> True end | _ -> True end let ni_com (env:label_fun) (c:com) (l:label) : Tot Type0 = (forall (h0: rel heap). (* {:pattern (low_equiv env h0)} *) ni_com' env c l h0) /\ (forall (h0:heap). (* {:pattern (Some? (interpret_com h0 c))} *) inv_com' env c l h0) (*********************** Typing Rules for Expressions **********************) (* CH: The way we derive these rules looks more like a semantically-justified program logic than a syntactic type system. Any connection to Dave Naumann and Anindya Banerjee's "relational logic"? (e.g. https://arxiv.org/abs/1611.08992) *) (* Subtyping rule for expression labels E |- e : l1 l1 <= l2 ---------------------- E |- e : l2 *) val sub_exp : env:label_fun -> e:exp -> l1:label -> l2:label -> Lemma (requires (l1 <= l2 /\ ni_exp env e l1)) (ensures (ni_exp env e l2)) let sub_exp _ _ _ _ = () (* Typing rule for dereferencing ---------------- E | - r : E(r) *) val avar_exp : env:label_fun -> r:id -> Lemma (ensures (ni_exp env (AVar r) (env r))) let avar_exp _ _ = () (* Typing rule for Int constants i : int ------- i : Low *) val aint_exp : env:label_fun -> i:int -> Lemma (requires True) (ensures (ni_exp env (AInt i) Low)) let aint_exp _ _ = () (* Typing rule for binary operators e1 : l e2 : l ---------------- e1 `op` e2 : l *) val binop_exp : env:label_fun -> op:binop -> e1:exp -> e2:exp -> l:label -> Lemma (requires (ni_exp env e1 l) /\ (ni_exp env e2 l)) (ensures (ni_exp env (AOp op e1 e2) l)) let binop_exp env op e1 e2 l = () (************************ Typing Rules for Commands ************************) (* Subtyping rule for commands env,pc:l1 |- c l2 <= l1 --------------------------- env,pc:l2 |- c *) val sub_com : env:label_fun -> c:com -> l1:label -> l2:label -> Lemma (requires (l2 <= l1 /\ ni_com env c l1 )) (ensures (ni_com env c l2 )) let sub_com _ _ _ _ = () (* Typing rule for assignment env |- e : env(r) ------------------------ env, pc:env(r) |- r := e - label of expression and context label have to be below label of r (first one to prevent explicit, second to prevent implicit flows) *) let assign_inv_com0 (env:label_fun) (e:exp) (r:id) (ne:squash(ni_exp env e (env r))) (h0:rel heap) : Lemma (ni_com' env (Assign r e) (env r) h0) = FStar.Squash.give_proof ne ; let vr = reify (interpret_exp_st e) (R?.r h0) in let vl = reify (interpret_exp_st e) (R?.l h0) in match reify (interpret_com_st (Assign r e) (R?.l h0)) (R?.l h0) with | Some (), h1l -> begin match reify (interpret_com_st (Assign r e) (R?.r h0)) (R?.r h0) with | Some (), h1r -> assert (h1l = upd (R?.l h0) r vl /\ h1r = upd (R?.r h0) r vr) | None, _ -> () end | None, _ -> () let assign_inv_com' (env:label_fun) (e:exp) (r:id) (h0:heap) : Lemma (inv_com' env (Assign r e) (env r) h0) = let v = reify (interpret_exp_st e) h0 in match reify (interpret_com_st (Assign r e) h0) h0 with | None, h1 -> () | Some (), h1 -> assert (h1 == upd h0 r v) val assign_com : env:label_fun -> e:exp -> r:id -> Lemma (requires (ni_exp env e (env r))) (ensures (ni_com env (Assign r e) (env r))) let assign_com env e r = forall_intro (assign_inv_com0 env e r (FStar.Squash.get_proof (ni_exp env e (env r)))) ; forall_intro (assign_inv_com' env e r) let seq_nil1 (c1:com) (c2:com) (h:heap) : Lemma (requires (fst (reify (interpret_com_st c1 h) h) = None)) (ensures (fst (reify (interpret_com_st (Seq c1 c2) h) h) = None)) = () let seq_nil2 (c1:com) (c2:com) (h0:heap) (h1:heap) : Lemma (requires (h1 == snd (reify (interpret_com_st c1 h0) h0) /\ fst (reify (interpret_com_st c2 h1) h1) = None)) (ensures (fst (reify (interpret_com_st (Seq c1 c2) h0) h0) = None)) = () (* Sequencing rule for commands env,pc:l |- c1 env,pc:l |- c2 ------------------------------ env,pc:l |- c1; c2 *) val seq_inv_com' : env:label_fun -> c1:com -> c2:com -> l:label -> h0:heap -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l))

env: IfcRulesReify.label_fun -> c1: WhileReify.com -> c2: WhileReify.com -> l: IfcRulesReify.label -> h0: FStar.DM4F.Heap.IntStoreFixed.heap -> FStar.Pervasives.Lemma (requires IfcRulesReify.ni_com env c1 l /\ IfcRulesReify.ni_com env c2 l) (ensures IfcRulesReify.inv_com' env (WhileReify.Seq c1 c2) l h0)

FStar.Pervasives.Lemma

let seq_inv_com' env c1 c2 l h0 =

match reify (interpret_com_st c1 h0) h0 with | None, _ -> seq_nil1 c1 c2 h0 | Some (), h1 -> match reify (interpret_com_st c2 h1) h1 with | None, _ -> seq_nil2 c1 c2 h0 h1 | Some (), h2 -> ()

IfcRulesReify.fst

IfcRulesReify.cond_inv_com'

val cond_inv_com' : env:label_fun -> e:exp -> ct:com -> cf:com -> l:label -> h0:heap -> Lemma (requires ((ni_exp env e l) /\ (ni_com env ct l) /\ (ni_com env cf l))) (ensures (inv_com' env (If e ct cf) l h0))

val cond_inv_com' : env:label_fun -> e:exp -> ct:com -> cf:com -> l:label -> h0:heap -> Lemma (requires ((ni_exp env e l) /\ (ni_com env ct l) /\ (ni_com env cf l))) (ensures (inv_com' env (If e ct cf) l h0))

let cond_inv_com' env e ct cf l h0 = let v = reify (interpret_exp_st e) h0 in if v = 0 then assert (inv_com' env cf l h0 ==> inv_com' env (If e ct cf) l h0) else assert (inv_com' env ct l h0 ==> inv_com' env (If e ct cf) l h0)

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module IfcRulesReify open Rel open WhileReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreExcFixed open FStar.Squash open FStar.Classical (****************************** Preliminaries ******************************) (* CH: Everything specialized to 2-point lattice *) type label = | Low | High val op_Less : label -> label -> Tot bool let op_Less l1 l2 = match l1, l2 with | Low,High -> true | _, _ -> false val op_Less_Equals : label -> label -> Tot bool let op_Less_Equals l1 l2 = match l1, l2 with | High,Low -> false | _, _ -> true val join : label -> label -> Tot label let join l1 l2 = match l1, l2 with | Low,Low -> Low | _, _ -> High val meet : label -> label -> Tot label let meet l1 l2 = match l1, l2 with | High, High -> High | _, _ -> Low let universal_property_meet l l1 l2 : Lemma (requires (l <= l1 /\ l <= l2)) (ensures (l <= meet l1 l2)) = () type label_fun = id -> Tot label type low_equiv (env:label_fun) (h1:rel heap) = (forall (x:id). (* {:pattern (env x)} *) env x = Low ==> index (R?.l h1) x = index (R?.r h1) x) (**************************** Typing Judgements ****************************) (* env |- e : l - Expressions do not modify the heap - Correctness - Low equivalent input heaps + Low label ==> same result *) let ni_exp (env:label_fun) (e:exp) (l:label) : Tot Type0 = forall (h: rel heap). (* {:pattern (low_equiv env h)} *) (low_equiv env h /\ Low? l) ==> (* interpret_exp (R?.r h) e = interpret_exp (R?.l h) e *) begin let vr = reify (interpret_exp_st e) (R?.r h)in let vl = reify (interpret_exp_st e) (R?.l h) in vr = vl end (* env,pc:l |- c - References with a label below l are not modified - Total correctness - Low equivalent input heaps ==> Low equivalent output heaps *) let inv_com' (env:label_fun) (c:com) (l:label) (h0:heap) : Tot Type0 = match interpret_com h0 c with | None -> True | Some h1 -> forall (i:id). (* {:pattern (env i < l)} *) env i < l ==> index h0 i = index h1 i let ni_com' (env:label_fun) (c:com) (l:label) (h0:rel heap) : Tot Type0 = let R h0l h0r = h0 in (* KM : That's the code that we would like to write but subtyping and matching on pairs interplay badly *) (* it generates a VC which boils down to [forall (h1l:heap). length h1l = length h0l] which is obviously false *) (* begin match interpret_com h0l c, interpret_com h0r c with *) (* | Some h1l, Some h1r -> low_equiv env (R h0l h0r) ==> low_equiv env (R h1l h1r) *) (* | _ -> True *) (* end *) begin match interpret_com h0l c with | Some h1l -> begin match interpret_com h0r c with | Some h1r -> low_equiv env h0 ==> low_equiv env (R h1l h1r) | _ -> True end | _ -> True end let ni_com (env:label_fun) (c:com) (l:label) : Tot Type0 = (forall (h0: rel heap). (* {:pattern (low_equiv env h0)} *) ni_com' env c l h0) /\ (forall (h0:heap). (* {:pattern (Some? (interpret_com h0 c))} *) inv_com' env c l h0) (*********************** Typing Rules for Expressions **********************) (* CH: The way we derive these rules looks more like a semantically-justified program logic than a syntactic type system. Any connection to Dave Naumann and Anindya Banerjee's "relational logic"? (e.g. https://arxiv.org/abs/1611.08992) *) (* Subtyping rule for expression labels E |- e : l1 l1 <= l2 ---------------------- E |- e : l2 *) val sub_exp : env:label_fun -> e:exp -> l1:label -> l2:label -> Lemma (requires (l1 <= l2 /\ ni_exp env e l1)) (ensures (ni_exp env e l2)) let sub_exp _ _ _ _ = () (* Typing rule for dereferencing ---------------- E | - r : E(r) *) val avar_exp : env:label_fun -> r:id -> Lemma (ensures (ni_exp env (AVar r) (env r))) let avar_exp _ _ = () (* Typing rule for Int constants i : int ------- i : Low *) val aint_exp : env:label_fun -> i:int -> Lemma (requires True) (ensures (ni_exp env (AInt i) Low)) let aint_exp _ _ = () (* Typing rule for binary operators e1 : l e2 : l ---------------- e1 `op` e2 : l *) val binop_exp : env:label_fun -> op:binop -> e1:exp -> e2:exp -> l:label -> Lemma (requires (ni_exp env e1 l) /\ (ni_exp env e2 l)) (ensures (ni_exp env (AOp op e1 e2) l)) let binop_exp env op e1 e2 l = () (************************ Typing Rules for Commands ************************) (* Subtyping rule for commands env,pc:l1 |- c l2 <= l1 --------------------------- env,pc:l2 |- c *) val sub_com : env:label_fun -> c:com -> l1:label -> l2:label -> Lemma (requires (l2 <= l1 /\ ni_com env c l1 )) (ensures (ni_com env c l2 )) let sub_com _ _ _ _ = () (* Typing rule for assignment env |- e : env(r) ------------------------ env, pc:env(r) |- r := e - label of expression and context label have to be below label of r (first one to prevent explicit, second to prevent implicit flows) *) let assign_inv_com0 (env:label_fun) (e:exp) (r:id) (ne:squash(ni_exp env e (env r))) (h0:rel heap) : Lemma (ni_com' env (Assign r e) (env r) h0) = FStar.Squash.give_proof ne ; let vr = reify (interpret_exp_st e) (R?.r h0) in let vl = reify (interpret_exp_st e) (R?.l h0) in match reify (interpret_com_st (Assign r e) (R?.l h0)) (R?.l h0) with | Some (), h1l -> begin match reify (interpret_com_st (Assign r e) (R?.r h0)) (R?.r h0) with | Some (), h1r -> assert (h1l = upd (R?.l h0) r vl /\ h1r = upd (R?.r h0) r vr) | None, _ -> () end | None, _ -> () let assign_inv_com' (env:label_fun) (e:exp) (r:id) (h0:heap) : Lemma (inv_com' env (Assign r e) (env r) h0) = let v = reify (interpret_exp_st e) h0 in match reify (interpret_com_st (Assign r e) h0) h0 with | None, h1 -> () | Some (), h1 -> assert (h1 == upd h0 r v) val assign_com : env:label_fun -> e:exp -> r:id -> Lemma (requires (ni_exp env e (env r))) (ensures (ni_com env (Assign r e) (env r))) let assign_com env e r = forall_intro (assign_inv_com0 env e r (FStar.Squash.get_proof (ni_exp env e (env r)))) ; forall_intro (assign_inv_com' env e r) let seq_nil1 (c1:com) (c2:com) (h:heap) : Lemma (requires (fst (reify (interpret_com_st c1 h) h) = None)) (ensures (fst (reify (interpret_com_st (Seq c1 c2) h) h) = None)) = () let seq_nil2 (c1:com) (c2:com) (h0:heap) (h1:heap) : Lemma (requires (h1 == snd (reify (interpret_com_st c1 h0) h0) /\ fst (reify (interpret_com_st c2 h1) h1) = None)) (ensures (fst (reify (interpret_com_st (Seq c1 c2) h0) h0) = None)) = () (* Sequencing rule for commands env,pc:l |- c1 env,pc:l |- c2 ------------------------------ env,pc:l |- c1; c2 *) val seq_inv_com' : env:label_fun -> c1:com -> c2:com -> l:label -> h0:heap -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (inv_com' env (Seq c1 c2) l h0)) let seq_inv_com' env c1 c2 l h0 = match reify (interpret_com_st c1 h0) h0 with | None, _ -> seq_nil1 c1 c2 h0 | Some (), h1 -> match reify (interpret_com_st c2 h1) h1 with | None, _ -> seq_nil2 c1 c2 h0 h1 | Some (), h2 -> () #set-options "--z3rlimit 50" let use_ni_com (env:label_fun) (c:com) (l:label) (h:rel heap{low_equiv env h}) : Lemma (requires ni_com env c l) (ensures (let R hl hr = h in match reify (interpret_com_st c hl) hl, reify (interpret_com_st c hr) hr with | (Some _, hl'), (Some _, hr') -> low_equiv env (R hl' hr') | _ -> True)) = () val seq_com' : env:label_fun -> c1:com -> c2:com -> l:label -> h0: rel heap -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (ni_com' env (Seq c1 c2) l h0)) let seq_com' env c1 c2 l h0 = if not (FStar.StrongExcludedMiddle.strong_excluded_middle (low_equiv env h0)) then () else begin assert (low_equiv env h0); let R h0l h0r = h0 in match reify (interpret_com_st c1 h0l) h0l with | None, _ -> seq_nil1 c1 c2 h0l | Some (), h1l -> match reify (interpret_com_st c1 h0r) h0r with | None, _ -> seq_nil1 c1 c2 h0r | Some (), h1r -> match reify (interpret_com_st c2 h1l) h1l with | None, _ -> seq_nil2 c1 c2 h0l h1l | Some (), h2l -> match reify (interpret_com_st c2 h1r) h1r with | None, _ -> seq_nil2 c1 c2 h0r h1r | Some (), h2r -> let h1 = R h1l h1r in use_ni_com env c1 l h0; assert (low_equiv env h1) ; let h2 = R h2l h2r in use_ni_com env c2 l h1; assert (low_equiv env h2) end val seq_com : env:label_fun -> c1:com -> c2:com -> l:label -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (ni_com env (Seq c1 c2) l)) let seq_com env c1 c2 l = forall_intro (fun (h0:rel heap) -> seq_com' env c1 c2 l h0 <: Lemma (ni_com' env (Seq c1 c2) l h0)) ; forall_intro (fun (h0:heap) -> seq_inv_com' env c1 c2 l h0 <: Lemma (inv_com' env (Seq c1 c2) l h0)) (* Typing rule for conditional commands env |- e : l env,pc:l |- ct env,pc:l |- cf ---------------------------------------------- env,pc:l |- if e <> 0 then ct else cf *) (* let project_inv_com' (env:label_fun) (c:com) (l:label) (h0:heap) : Lemma (requires (ni_com env c l)) (ensures (inv_com' env c l h0)) = () *) val cond_inv_com' : env:label_fun -> e:exp -> ct:com -> cf:com -> l:label -> h0:heap -> Lemma (requires ((ni_exp env e l) /\ (ni_com env ct l) /\ (ni_com env cf l)))

env: IfcRulesReify.label_fun -> e: WhileReify.exp -> ct: WhileReify.com -> cf: WhileReify.com -> l: IfcRulesReify.label -> h0: FStar.DM4F.Heap.IntStoreFixed.heap -> FStar.Pervasives.Lemma (requires IfcRulesReify.ni_exp env e l /\ IfcRulesReify.ni_com env ct l /\ IfcRulesReify.ni_com env cf l) (ensures IfcRulesReify.inv_com' env (WhileReify.If e ct cf) l h0)

FStar.Pervasives.Lemma

let cond_inv_com' env e ct cf l h0 =

let v = reify (interpret_exp_st e) h0 in if v = 0 then assert (inv_com' env cf l h0 ==> inv_com' env (If e ct cf) l h0) else assert (inv_com' env ct l h0 ==> inv_com' env (If e ct cf) l h0)

Pulse.Checker.IntroPure.fst

Pulse.Checker.IntroPure.check

val check (g:env) (pre:term) (pre_typing:tot_typing g pre tm_vprop) (post_hint:post_hint_opt g) (res_ppname:ppname) (t:st_term { Tm_IntroPure? t.term }) : T.Tac (checker_result_t g pre post_hint)

val check (g:env) (pre:term) (pre_typing:tot_typing g pre tm_vprop) (post_hint:post_hint_opt g) (res_ppname:ppname) (t:st_term { Tm_IntroPure? t.term }) : T.Tac (checker_result_t g pre post_hint)

let check (g:env) (pre:term) (pre_typing:tot_typing g pre tm_vprop) (post_hint:post_hint_opt g) (res_ppname:ppname) (t:st_term { Tm_IntroPure? t.term }) : T.Tac (checker_result_t g pre post_hint) = let g = Pulse.Typing.Env.push_context g "check_intro_pure" t.range in let Tm_IntroPure { p } = t.term in let (| p, p_typing |) = check_prop g p in let pv = check_prop_validity g p p_typing in let st_typing = T_IntroPure _ _ p_typing pv in prove_post_hint (try_frame_pre pre_typing (match_comp_res_with_post_hint st_typing post_hint) res_ppname) post_hint t.range

(* 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.IntroPure open Pulse.Syntax open Pulse.Typing open Pulse.Checker.Base open Pulse.Checker.Prover module T = FStar.Tactics.V2 module P = Pulse.Syntax.Printer let check_prop (g:env) (p:term) : T.Tac (p:term & tot_typing g p tm_prop) = let p0 = p in let (| p, p_typing |) = Pulse.Checker.Pure.check_vprop g (tm_pure p) in match p.t with | Tm_Pure pp -> let prop_typing = Pulse.Typing.Metatheory.pure_typing_inversion #_ #pp p_typing in (| pp, prop_typing |) | _ -> fail g None (Printf.sprintf "Impossible: check_intro_pure: checking a pure vprop %s returned a non-pure vprop %s,\ please file a bug-report" (P.term_to_string (tm_pure p0)) (P.term_to_string p)) let check_prop_validity (g:env) (p:term) (typing:tot_typing g p tm_prop): T.Tac (prop_validity g p) = Pulse.Checker.Pure.check_prop_validity g p typing

g: Pulse.Typing.Env.env -> pre: Pulse.Syntax.Base.term -> pre_typing: Pulse.Typing.tot_typing g pre Pulse.Syntax.Base.tm_vprop -> post_hint: Pulse.Typing.post_hint_opt g -> res_ppname: Pulse.Syntax.Base.ppname -> t: Pulse.Syntax.Base.st_term{Tm_IntroPure? (Mkst_term?.term t)} -> FStar.Tactics.Effect.Tac (Pulse.Checker.Base.checker_result_t g pre post_hint)

FStar.Tactics.Effect.Tac

let check (g: env) (pre: term) (pre_typing: tot_typing g pre tm_vprop) (post_hint: post_hint_opt g) (res_ppname: ppname) (t: st_term{Tm_IntroPure? t.term}) : T.Tac (checker_result_t g pre post_hint) =

let g = Pulse.Typing.Env.push_context g "check_intro_pure" t.range in let Tm_IntroPure { p = p } = t.term in let (| p , p_typing |) = check_prop g p in let pv = check_prop_validity g p p_typing in let st_typing = T_IntroPure _ _ p_typing pv in prove_post_hint (try_frame_pre pre_typing (match_comp_res_with_post_hint st_typing post_hint) res_ppname) post_hint t.range

Hacl.Spec.SHA2.Lemmas.fst

Hacl.Spec.SHA2.Lemmas.transpose_state_lemma_ij

val transpose_state_lemma_ij: #a:sha2_alg -> #m:m_spec{is_supported a m} -> st:state_spec a m -> j:nat{j < lanes a m} -> i:nat{i < 8 * word_length a} -> Lemma (let l = lanes a m in let ind = 8 * j + i / word_length a in (Seq.index (vec_v (transpose_state st).[ind / l])) (ind % l) == (Seq.index (state_spec_v st).[j] (i / word_length a)))

val transpose_state_lemma_ij: #a:sha2_alg -> #m:m_spec{is_supported a m} -> st:state_spec a m -> j:nat{j < lanes a m} -> i:nat{i < 8 * word_length a} -> Lemma (let l = lanes a m in let ind = 8 * j + i / word_length a in (Seq.index (vec_v (transpose_state st).[ind / l])) (ind % l) == (Seq.index (state_spec_v st).[j] (i / word_length a)))

let transpose_state_lemma_ij #a #m st j i = match lanes a m with | 1 -> () | 4 -> transpose_state4_lemma #a #m st j i | 8 -> transpose_state8_lemma #a #m st j i

module Hacl.Spec.SHA2.Lemmas open FStar.Mul open Lib.IntTypes open Lib.Sequence open Lib.IntVector open Lib.IntVector.Transpose open Spec.Hash.Definitions open Hacl.Spec.SHA2.Vec #set-options "--z3rlimit 50 --fuel 0 --ifuel 1" val transpose_ws4_lemma_ij: #a:sha2_alg -> #m:m_spec{lanes a m == 4} // lanes a m * lanes a m = 16 -> ws:ws_spec a m -> j:nat{j < lanes a m} -> i:nat{i < 16} -> Lemma (let l = lanes a m in (vec_v (transpose_ws4 ws).[i]).[j] == (vec_v ws.[i / l * l + j]).[i % l]) let transpose_ws4_lemma_ij #a #m ws j i = let l = lanes a m in let i_sub = i / l in let j_sub = i % l in assert (i_sub * l + j_sub == i); let vs = sub ws (i_sub * l) l in eq_intro (sub (transpose_ws4 ws) (i_sub * l) l) (transpose4x4_lseq vs); //assert ((transpose_ws4 ws).[i] == (sub (transpose_ws4 ws) (i_sub * l) l).[j_sub]); //assert ((transpose_ws4 ws).[i] == (transpose4x4_lseq vs).[j_sub]); assert ((vec_v (transpose_ws4 ws).[i]).[j] == (vec_v (transpose4x4_lseq vs).[j_sub]).[j]); transpose4x4_lemma vs; assert ((vec_v (transpose_ws4 ws).[i]).[j] == (vec_v vs.[j]).[j_sub]); assert ((vec_v (transpose_ws4 ws).[i]).[j] == (vec_v ws.[i_sub * l + j]).[j_sub]) val transpose_ws8_lemma_ij: #a:sha2_alg -> #m:m_spec{lanes a m == 8} -> ws:ws_spec a m -> j:nat{j < lanes a m} -> i:nat{i < 16} -> Lemma (let l = lanes a m in (vec_v (transpose_ws8 ws).[i]).[j] == (vec_v ws.[i / l * l + j]).[i % l]) let transpose_ws8_lemma_ij #a #m ws j i = let l = lanes a m in let i_sub = i / l in let j_sub = i % l in assert (i_sub * l + j_sub == i); let vs = sub ws (i_sub * l) l in eq_intro (sub (transpose_ws8 ws) (i_sub * l) l) (transpose8x8_lseq vs); assert ((vec_v (transpose_ws8 ws).[i]).[j] == (vec_v (transpose8x8_lseq vs).[j_sub]).[j]); transpose8x8_lemma vs; assert ((vec_v (transpose_ws8 ws).[i]).[j] == (vec_v ws.[i_sub * lanes a m + j]).[j_sub]) val transpose_ws_lemma_ij: #a:sha2_alg -> #m:m_spec{is_supported a m} -> ws:ws_spec a m -> j:nat{j < lanes a m} -> i:nat{i < 16} -> Lemma (let l = lanes a m in ((ws_spec_v (transpose_ws ws)).[j]).[i] == (vec_v ws.[i / l * l + j]).[i % l]) let transpose_ws_lemma_ij #a #m ws j i = assert (((ws_spec_v (transpose_ws ws)).[j]).[i] == (vec_v (transpose_ws ws).[i]).[j]); match lanes a m with | 1 -> () | 4 -> transpose_ws4_lemma_ij #a #m ws j i | 8 -> transpose_ws8_lemma_ij #a #m ws j i val transpose_state4_lemma: #a:sha2_alg -> #m:m_spec{lanes a m == 4} -> st:state_spec a m -> j:nat{j < lanes a m} -> i:nat{i < 8 * word_length a} -> Lemma (let l = lanes a m in let ind = 8 * j + i / word_length a in Seq.index (vec_v (transpose_state st).[ind / l]) (ind % l) == Seq.index (state_spec_v st).[j] (i / word_length a)) let transpose_state4_lemma #a #m st j i = let r0 = transpose4x4_lseq (sub st 0 4) in transpose4x4_lemma (sub st 0 4); let r1 = transpose4x4_lseq (sub st 4 4) in transpose4x4_lemma (sub st 4 4) val transpose_state8_lemma: #a:sha2_alg -> #m:m_spec{lanes a m == 8} -> st:state_spec a m -> j:nat{j < lanes a m} -> i:nat{i < 8 * word_length a} -> Lemma (let l = lanes a m in let ind = 8 * j + i / word_length a in Seq.index (vec_v (transpose_state8 st).[ind / l]) (ind % l) == Seq.index (state_spec_v st).[j] (i / word_length a)) let transpose_state8_lemma #a #m st j i = let l = lanes a m in let ind = 8 * j + i / word_length a in let r0 = transpose8x8_lseq st in transpose8x8_lemma st val transpose_state_lemma_ij: #a:sha2_alg -> #m:m_spec{is_supported a m} -> st:state_spec a m -> j:nat{j < lanes a m} -> i:nat{i < 8 * word_length a} -> Lemma (let l = lanes a m in let ind = 8 * j + i / word_length a in (Seq.index (vec_v (transpose_state st).[ind / l])) (ind % l) == (Seq.index (state_spec_v st).[j] (i / word_length a)))

st: Hacl.Spec.SHA2.Vec.state_spec a m -> j: Prims.nat{j < Hacl.Spec.SHA2.Vec.lanes a m} -> i: Prims.nat{i < 8 * Spec.Hash.Definitions.word_length a} -> FStar.Pervasives.Lemma (ensures (let l = Hacl.Spec.SHA2.Vec.lanes a m in let ind = 8 * j + i / Spec.Hash.Definitions.word_length a in FStar.Seq.Base.index (Lib.IntVector.vec_v (Hacl.Spec.SHA2.Vec.transpose_state st).[ ind / l ]) (ind % l) == FStar.Seq.Base.index (Hacl.Spec.SHA2.Vec.state_spec_v st).[ j ] (i / Spec.Hash.Definitions.word_length a)))

FStar.Pervasives.Lemma

let transpose_state_lemma_ij #a #m st j i =

match lanes a m with | 1 -> () | 4 -> transpose_state4_lemma #a #m st j i | 8 -> transpose_state8_lemma #a #m st j i

IfcRulesReify.fst

IfcRulesReify.cond_com

val cond_com : env:label_fun -> e:exp -> ct:com -> cf:com -> l:label -> Lemma (requires ((ni_exp env e l) /\ (ni_com env ct l) /\ (ni_com env cf l))) (ensures (ni_com env (If e ct cf) l))

val cond_com : env:label_fun -> e:exp -> ct:com -> cf:com -> l:label -> Lemma (requires ((ni_exp env e l) /\ (ni_com env ct l) /\ (ni_com env cf l))) (ensures (ni_com env (If e ct cf) l))

let cond_com env e ct cf l = forall_intro (fun (h0:rel heap) -> cond_ni_com' env e ct cf l h0 <: Lemma (ni_com' env (If e ct cf) l h0)) ; forall_intro (fun (h0:heap) -> cond_inv_com' env e ct cf l h0 <: Lemma (inv_com' env (If e ct cf) l h0))

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module IfcRulesReify open Rel open WhileReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreExcFixed open FStar.Squash open FStar.Classical (****************************** Preliminaries ******************************) (* CH: Everything specialized to 2-point lattice *) type label = | Low | High val op_Less : label -> label -> Tot bool let op_Less l1 l2 = match l1, l2 with | Low,High -> true | _, _ -> false val op_Less_Equals : label -> label -> Tot bool let op_Less_Equals l1 l2 = match l1, l2 with | High,Low -> false | _, _ -> true val join : label -> label -> Tot label let join l1 l2 = match l1, l2 with | Low,Low -> Low | _, _ -> High val meet : label -> label -> Tot label let meet l1 l2 = match l1, l2 with | High, High -> High | _, _ -> Low let universal_property_meet l l1 l2 : Lemma (requires (l <= l1 /\ l <= l2)) (ensures (l <= meet l1 l2)) = () type label_fun = id -> Tot label type low_equiv (env:label_fun) (h1:rel heap) = (forall (x:id). (* {:pattern (env x)} *) env x = Low ==> index (R?.l h1) x = index (R?.r h1) x) (**************************** Typing Judgements ****************************) (* env |- e : l - Expressions do not modify the heap - Correctness - Low equivalent input heaps + Low label ==> same result *) let ni_exp (env:label_fun) (e:exp) (l:label) : Tot Type0 = forall (h: rel heap). (* {:pattern (low_equiv env h)} *) (low_equiv env h /\ Low? l) ==> (* interpret_exp (R?.r h) e = interpret_exp (R?.l h) e *) begin let vr = reify (interpret_exp_st e) (R?.r h)in let vl = reify (interpret_exp_st e) (R?.l h) in vr = vl end (* env,pc:l |- c - References with a label below l are not modified - Total correctness - Low equivalent input heaps ==> Low equivalent output heaps *) let inv_com' (env:label_fun) (c:com) (l:label) (h0:heap) : Tot Type0 = match interpret_com h0 c with | None -> True | Some h1 -> forall (i:id). (* {:pattern (env i < l)} *) env i < l ==> index h0 i = index h1 i let ni_com' (env:label_fun) (c:com) (l:label) (h0:rel heap) : Tot Type0 = let R h0l h0r = h0 in (* KM : That's the code that we would like to write but subtyping and matching on pairs interplay badly *) (* it generates a VC which boils down to [forall (h1l:heap). length h1l = length h0l] which is obviously false *) (* begin match interpret_com h0l c, interpret_com h0r c with *) (* | Some h1l, Some h1r -> low_equiv env (R h0l h0r) ==> low_equiv env (R h1l h1r) *) (* | _ -> True *) (* end *) begin match interpret_com h0l c with | Some h1l -> begin match interpret_com h0r c with | Some h1r -> low_equiv env h0 ==> low_equiv env (R h1l h1r) | _ -> True end | _ -> True end let ni_com (env:label_fun) (c:com) (l:label) : Tot Type0 = (forall (h0: rel heap). (* {:pattern (low_equiv env h0)} *) ni_com' env c l h0) /\ (forall (h0:heap). (* {:pattern (Some? (interpret_com h0 c))} *) inv_com' env c l h0) (*********************** Typing Rules for Expressions **********************) (* CH: The way we derive these rules looks more like a semantically-justified program logic than a syntactic type system. Any connection to Dave Naumann and Anindya Banerjee's "relational logic"? (e.g. https://arxiv.org/abs/1611.08992) *) (* Subtyping rule for expression labels E |- e : l1 l1 <= l2 ---------------------- E |- e : l2 *) val sub_exp : env:label_fun -> e:exp -> l1:label -> l2:label -> Lemma (requires (l1 <= l2 /\ ni_exp env e l1)) (ensures (ni_exp env e l2)) let sub_exp _ _ _ _ = () (* Typing rule for dereferencing ---------------- E | - r : E(r) *) val avar_exp : env:label_fun -> r:id -> Lemma (ensures (ni_exp env (AVar r) (env r))) let avar_exp _ _ = () (* Typing rule for Int constants i : int ------- i : Low *) val aint_exp : env:label_fun -> i:int -> Lemma (requires True) (ensures (ni_exp env (AInt i) Low)) let aint_exp _ _ = () (* Typing rule for binary operators e1 : l e2 : l ---------------- e1 `op` e2 : l *) val binop_exp : env:label_fun -> op:binop -> e1:exp -> e2:exp -> l:label -> Lemma (requires (ni_exp env e1 l) /\ (ni_exp env e2 l)) (ensures (ni_exp env (AOp op e1 e2) l)) let binop_exp env op e1 e2 l = () (************************ Typing Rules for Commands ************************) (* Subtyping rule for commands env,pc:l1 |- c l2 <= l1 --------------------------- env,pc:l2 |- c *) val sub_com : env:label_fun -> c:com -> l1:label -> l2:label -> Lemma (requires (l2 <= l1 /\ ni_com env c l1 )) (ensures (ni_com env c l2 )) let sub_com _ _ _ _ = () (* Typing rule for assignment env |- e : env(r) ------------------------ env, pc:env(r) |- r := e - label of expression and context label have to be below label of r (first one to prevent explicit, second to prevent implicit flows) *) let assign_inv_com0 (env:label_fun) (e:exp) (r:id) (ne:squash(ni_exp env e (env r))) (h0:rel heap) : Lemma (ni_com' env (Assign r e) (env r) h0) = FStar.Squash.give_proof ne ; let vr = reify (interpret_exp_st e) (R?.r h0) in let vl = reify (interpret_exp_st e) (R?.l h0) in match reify (interpret_com_st (Assign r e) (R?.l h0)) (R?.l h0) with | Some (), h1l -> begin match reify (interpret_com_st (Assign r e) (R?.r h0)) (R?.r h0) with | Some (), h1r -> assert (h1l = upd (R?.l h0) r vl /\ h1r = upd (R?.r h0) r vr) | None, _ -> () end | None, _ -> () let assign_inv_com' (env:label_fun) (e:exp) (r:id) (h0:heap) : Lemma (inv_com' env (Assign r e) (env r) h0) = let v = reify (interpret_exp_st e) h0 in match reify (interpret_com_st (Assign r e) h0) h0 with | None, h1 -> () | Some (), h1 -> assert (h1 == upd h0 r v) val assign_com : env:label_fun -> e:exp -> r:id -> Lemma (requires (ni_exp env e (env r))) (ensures (ni_com env (Assign r e) (env r))) let assign_com env e r = forall_intro (assign_inv_com0 env e r (FStar.Squash.get_proof (ni_exp env e (env r)))) ; forall_intro (assign_inv_com' env e r) let seq_nil1 (c1:com) (c2:com) (h:heap) : Lemma (requires (fst (reify (interpret_com_st c1 h) h) = None)) (ensures (fst (reify (interpret_com_st (Seq c1 c2) h) h) = None)) = () let seq_nil2 (c1:com) (c2:com) (h0:heap) (h1:heap) : Lemma (requires (h1 == snd (reify (interpret_com_st c1 h0) h0) /\ fst (reify (interpret_com_st c2 h1) h1) = None)) (ensures (fst (reify (interpret_com_st (Seq c1 c2) h0) h0) = None)) = () (* Sequencing rule for commands env,pc:l |- c1 env,pc:l |- c2 ------------------------------ env,pc:l |- c1; c2 *) val seq_inv_com' : env:label_fun -> c1:com -> c2:com -> l:label -> h0:heap -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (inv_com' env (Seq c1 c2) l h0)) let seq_inv_com' env c1 c2 l h0 = match reify (interpret_com_st c1 h0) h0 with | None, _ -> seq_nil1 c1 c2 h0 | Some (), h1 -> match reify (interpret_com_st c2 h1) h1 with | None, _ -> seq_nil2 c1 c2 h0 h1 | Some (), h2 -> () #set-options "--z3rlimit 50" let use_ni_com (env:label_fun) (c:com) (l:label) (h:rel heap{low_equiv env h}) : Lemma (requires ni_com env c l) (ensures (let R hl hr = h in match reify (interpret_com_st c hl) hl, reify (interpret_com_st c hr) hr with | (Some _, hl'), (Some _, hr') -> low_equiv env (R hl' hr') | _ -> True)) = () val seq_com' : env:label_fun -> c1:com -> c2:com -> l:label -> h0: rel heap -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (ni_com' env (Seq c1 c2) l h0)) let seq_com' env c1 c2 l h0 = if not (FStar.StrongExcludedMiddle.strong_excluded_middle (low_equiv env h0)) then () else begin assert (low_equiv env h0); let R h0l h0r = h0 in match reify (interpret_com_st c1 h0l) h0l with | None, _ -> seq_nil1 c1 c2 h0l | Some (), h1l -> match reify (interpret_com_st c1 h0r) h0r with | None, _ -> seq_nil1 c1 c2 h0r | Some (), h1r -> match reify (interpret_com_st c2 h1l) h1l with | None, _ -> seq_nil2 c1 c2 h0l h1l | Some (), h2l -> match reify (interpret_com_st c2 h1r) h1r with | None, _ -> seq_nil2 c1 c2 h0r h1r | Some (), h2r -> let h1 = R h1l h1r in use_ni_com env c1 l h0; assert (low_equiv env h1) ; let h2 = R h2l h2r in use_ni_com env c2 l h1; assert (low_equiv env h2) end val seq_com : env:label_fun -> c1:com -> c2:com -> l:label -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (ni_com env (Seq c1 c2) l)) let seq_com env c1 c2 l = forall_intro (fun (h0:rel heap) -> seq_com' env c1 c2 l h0 <: Lemma (ni_com' env (Seq c1 c2) l h0)) ; forall_intro (fun (h0:heap) -> seq_inv_com' env c1 c2 l h0 <: Lemma (inv_com' env (Seq c1 c2) l h0)) (* Typing rule for conditional commands env |- e : l env,pc:l |- ct env,pc:l |- cf ---------------------------------------------- env,pc:l |- if e <> 0 then ct else cf *) (* let project_inv_com' (env:label_fun) (c:com) (l:label) (h0:heap) : Lemma (requires (ni_com env c l)) (ensures (inv_com' env c l h0)) = () *) val cond_inv_com' : env:label_fun -> e:exp -> ct:com -> cf:com -> l:label -> h0:heap -> Lemma (requires ((ni_exp env e l) /\ (ni_com env ct l) /\ (ni_com env cf l))) (ensures (inv_com' env (If e ct cf) l h0)) let cond_inv_com' env e ct cf l h0 = let v = reify (interpret_exp_st e) h0 in if v = 0 then assert (inv_com' env cf l h0 ==> inv_com' env (If e ct cf) l h0) else assert (inv_com' env ct l h0 ==> inv_com' env (If e ct cf) l h0) (* Works too but takes 20s more *) (* let c = if v = 0 then cf else ct in *) (* match reify (interpret_com_st c h0) h0 with *) (* | None, _ -> () *) (* | Some (), h1 -> () *) #reset-options "--max_fuel 1" let interpret_cond (e:exp) (ct:com) (cf:com) (h:heap) : Lemma (let v = reify (interpret_exp_st e) h in let c = if v = 0 then cf else ct in (reify (interpret_com_st (If e ct cf) h) h == reify (interpret_com_st c h) h)) = () val cond_ni_com' : env:label_fun -> e:exp -> ct:com -> cf:com -> l:label -> h0:rel heap -> Lemma (requires ((ni_exp env e l) /\ (ni_com env ct l) /\ (ni_com env cf l))) (ensures (ni_com' env (If e ct cf) l h0)) let cond_ni_com' env e ct cf l h0 = if not (FStar.StrongExcludedMiddle.strong_excluded_middle (low_equiv env h0)) then () else let R h0l h0r = h0 in let vl = reify (interpret_exp_st e) h0l in let vr = reify (interpret_exp_st e) h0r in if Low? l then begin assert (vl == vr) ; let c = if vl = 0 then cf else ct in assert (ni_com env c l) ; let cif = If e ct cf in //NS:05/15 ... this 2 should be trivial to prove. // Why do they require a lemma? interpret_cond e ct cf h0l; interpret_cond e ct cf h0r; use_ni_com env c l (R h0l h0r) end else (* h0 and h1 are low_equiv since cl and cr cannot write at low cells *) match reify (interpret_com_st (If e ct cf) h0l) h0l with | None, _ -> () | Some (), h1l -> match reify (interpret_com_st (If e ct cf) h0r) h0r with | None, _ -> () | Some (), h1r -> cond_inv_com' env e ct cf l h0l ; cond_inv_com' env e ct cf l h0r ; assert (low_equiv env h0 ==> low_equiv env (R h1l h1r)) #set-options "--z3rlimit 5" val cond_com : env:label_fun -> e:exp -> ct:com -> cf:com -> l:label -> Lemma (requires ((ni_exp env e l) /\ (ni_com env ct l) /\ (ni_com env cf l)))

env: IfcRulesReify.label_fun -> e: WhileReify.exp -> ct: WhileReify.com -> cf: WhileReify.com -> l: IfcRulesReify.label -> FStar.Pervasives.Lemma (requires IfcRulesReify.ni_exp env e l /\ IfcRulesReify.ni_com env ct l /\ IfcRulesReify.ni_com env cf l) (ensures IfcRulesReify.ni_com env (WhileReify.If e ct cf) l)

FStar.Pervasives.Lemma

let cond_com env e ct cf l =

forall_intro (fun (h0: rel heap) -> cond_ni_com' env e ct cf l h0 <: Lemma (ni_com' env (If e ct cf) l h0)); forall_intro (fun (h0: heap) -> cond_inv_com' env e ct cf l h0 <: Lemma (inv_com' env (If e ct cf) l h0))

IfcRulesReify.fst

IfcRulesReify.while_com

val while_com : env:label_fun -> e:exp -> c:com -> v:metric -> l:label -> Lemma (requires (ni_exp env e l /\ ni_com env c l)) (ensures (ni_com env (While e c v) l))

val while_com : env:label_fun -> e:exp -> c:com -> v:metric -> l:label -> Lemma (requires (ni_exp env e l /\ ni_com env c l)) (ensures (ni_com env (While e c v) l))

let while_com env e c v l = forall_intro (fun (h:rel heap) -> while_ni_com' env e c v l h <: Lemma (ensures (ni_com' env (While e c v) l h))) ; forall_intro (fun (h0:heap) -> while_inv_com' env e c v l h0 <: Lemma (ensures (inv_com' env (While e c v) l h0)))

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module IfcRulesReify open Rel open WhileReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreExcFixed open FStar.Squash open FStar.Classical (****************************** Preliminaries ******************************) (* CH: Everything specialized to 2-point lattice *) type label = | Low | High val op_Less : label -> label -> Tot bool let op_Less l1 l2 = match l1, l2 with | Low,High -> true | _, _ -> false val op_Less_Equals : label -> label -> Tot bool let op_Less_Equals l1 l2 = match l1, l2 with | High,Low -> false | _, _ -> true val join : label -> label -> Tot label let join l1 l2 = match l1, l2 with | Low,Low -> Low | _, _ -> High val meet : label -> label -> Tot label let meet l1 l2 = match l1, l2 with | High, High -> High | _, _ -> Low let universal_property_meet l l1 l2 : Lemma (requires (l <= l1 /\ l <= l2)) (ensures (l <= meet l1 l2)) = () type label_fun = id -> Tot label type low_equiv (env:label_fun) (h1:rel heap) = (forall (x:id). (* {:pattern (env x)} *) env x = Low ==> index (R?.l h1) x = index (R?.r h1) x) (**************************** Typing Judgements ****************************) (* env |- e : l - Expressions do not modify the heap - Correctness - Low equivalent input heaps + Low label ==> same result *) let ni_exp (env:label_fun) (e:exp) (l:label) : Tot Type0 = forall (h: rel heap). (* {:pattern (low_equiv env h)} *) (low_equiv env h /\ Low? l) ==> (* interpret_exp (R?.r h) e = interpret_exp (R?.l h) e *) begin let vr = reify (interpret_exp_st e) (R?.r h)in let vl = reify (interpret_exp_st e) (R?.l h) in vr = vl end (* env,pc:l |- c - References with a label below l are not modified - Total correctness - Low equivalent input heaps ==> Low equivalent output heaps *) let inv_com' (env:label_fun) (c:com) (l:label) (h0:heap) : Tot Type0 = match interpret_com h0 c with | None -> True | Some h1 -> forall (i:id). (* {:pattern (env i < l)} *) env i < l ==> index h0 i = index h1 i let ni_com' (env:label_fun) (c:com) (l:label) (h0:rel heap) : Tot Type0 = let R h0l h0r = h0 in (* KM : That's the code that we would like to write but subtyping and matching on pairs interplay badly *) (* it generates a VC which boils down to [forall (h1l:heap). length h1l = length h0l] which is obviously false *) (* begin match interpret_com h0l c, interpret_com h0r c with *) (* | Some h1l, Some h1r -> low_equiv env (R h0l h0r) ==> low_equiv env (R h1l h1r) *) (* | _ -> True *) (* end *) begin match interpret_com h0l c with | Some h1l -> begin match interpret_com h0r c with | Some h1r -> low_equiv env h0 ==> low_equiv env (R h1l h1r) | _ -> True end | _ -> True end let ni_com (env:label_fun) (c:com) (l:label) : Tot Type0 = (forall (h0: rel heap). (* {:pattern (low_equiv env h0)} *) ni_com' env c l h0) /\ (forall (h0:heap). (* {:pattern (Some? (interpret_com h0 c))} *) inv_com' env c l h0) (*********************** Typing Rules for Expressions **********************) (* CH: The way we derive these rules looks more like a semantically-justified program logic than a syntactic type system. Any connection to Dave Naumann and Anindya Banerjee's "relational logic"? (e.g. https://arxiv.org/abs/1611.08992) *) (* Subtyping rule for expression labels E |- e : l1 l1 <= l2 ---------------------- E |- e : l2 *) val sub_exp : env:label_fun -> e:exp -> l1:label -> l2:label -> Lemma (requires (l1 <= l2 /\ ni_exp env e l1)) (ensures (ni_exp env e l2)) let sub_exp _ _ _ _ = () (* Typing rule for dereferencing ---------------- E | - r : E(r) *) val avar_exp : env:label_fun -> r:id -> Lemma (ensures (ni_exp env (AVar r) (env r))) let avar_exp _ _ = () (* Typing rule for Int constants i : int ------- i : Low *) val aint_exp : env:label_fun -> i:int -> Lemma (requires True) (ensures (ni_exp env (AInt i) Low)) let aint_exp _ _ = () (* Typing rule for binary operators e1 : l e2 : l ---------------- e1 `op` e2 : l *) val binop_exp : env:label_fun -> op:binop -> e1:exp -> e2:exp -> l:label -> Lemma (requires (ni_exp env e1 l) /\ (ni_exp env e2 l)) (ensures (ni_exp env (AOp op e1 e2) l)) let binop_exp env op e1 e2 l = () (************************ Typing Rules for Commands ************************) (* Subtyping rule for commands env,pc:l1 |- c l2 <= l1 --------------------------- env,pc:l2 |- c *) val sub_com : env:label_fun -> c:com -> l1:label -> l2:label -> Lemma (requires (l2 <= l1 /\ ni_com env c l1 )) (ensures (ni_com env c l2 )) let sub_com _ _ _ _ = () (* Typing rule for assignment env |- e : env(r) ------------------------ env, pc:env(r) |- r := e - label of expression and context label have to be below label of r (first one to prevent explicit, second to prevent implicit flows) *) let assign_inv_com0 (env:label_fun) (e:exp) (r:id) (ne:squash(ni_exp env e (env r))) (h0:rel heap) : Lemma (ni_com' env (Assign r e) (env r) h0) = FStar.Squash.give_proof ne ; let vr = reify (interpret_exp_st e) (R?.r h0) in let vl = reify (interpret_exp_st e) (R?.l h0) in match reify (interpret_com_st (Assign r e) (R?.l h0)) (R?.l h0) with | Some (), h1l -> begin match reify (interpret_com_st (Assign r e) (R?.r h0)) (R?.r h0) with | Some (), h1r -> assert (h1l = upd (R?.l h0) r vl /\ h1r = upd (R?.r h0) r vr) | None, _ -> () end | None, _ -> () let assign_inv_com' (env:label_fun) (e:exp) (r:id) (h0:heap) : Lemma (inv_com' env (Assign r e) (env r) h0) = let v = reify (interpret_exp_st e) h0 in match reify (interpret_com_st (Assign r e) h0) h0 with | None, h1 -> () | Some (), h1 -> assert (h1 == upd h0 r v) val assign_com : env:label_fun -> e:exp -> r:id -> Lemma (requires (ni_exp env e (env r))) (ensures (ni_com env (Assign r e) (env r))) let assign_com env e r = forall_intro (assign_inv_com0 env e r (FStar.Squash.get_proof (ni_exp env e (env r)))) ; forall_intro (assign_inv_com' env e r) let seq_nil1 (c1:com) (c2:com) (h:heap) : Lemma (requires (fst (reify (interpret_com_st c1 h) h) = None)) (ensures (fst (reify (interpret_com_st (Seq c1 c2) h) h) = None)) = () let seq_nil2 (c1:com) (c2:com) (h0:heap) (h1:heap) : Lemma (requires (h1 == snd (reify (interpret_com_st c1 h0) h0) /\ fst (reify (interpret_com_st c2 h1) h1) = None)) (ensures (fst (reify (interpret_com_st (Seq c1 c2) h0) h0) = None)) = () (* Sequencing rule for commands env,pc:l |- c1 env,pc:l |- c2 ------------------------------ env,pc:l |- c1; c2 *) val seq_inv_com' : env:label_fun -> c1:com -> c2:com -> l:label -> h0:heap -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (inv_com' env (Seq c1 c2) l h0)) let seq_inv_com' env c1 c2 l h0 = match reify (interpret_com_st c1 h0) h0 with | None, _ -> seq_nil1 c1 c2 h0 | Some (), h1 -> match reify (interpret_com_st c2 h1) h1 with | None, _ -> seq_nil2 c1 c2 h0 h1 | Some (), h2 -> () #set-options "--z3rlimit 50" let use_ni_com (env:label_fun) (c:com) (l:label) (h:rel heap{low_equiv env h}) : Lemma (requires ni_com env c l) (ensures (let R hl hr = h in match reify (interpret_com_st c hl) hl, reify (interpret_com_st c hr) hr with | (Some _, hl'), (Some _, hr') -> low_equiv env (R hl' hr') | _ -> True)) = () val seq_com' : env:label_fun -> c1:com -> c2:com -> l:label -> h0: rel heap -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (ni_com' env (Seq c1 c2) l h0)) let seq_com' env c1 c2 l h0 = if not (FStar.StrongExcludedMiddle.strong_excluded_middle (low_equiv env h0)) then () else begin assert (low_equiv env h0); let R h0l h0r = h0 in match reify (interpret_com_st c1 h0l) h0l with | None, _ -> seq_nil1 c1 c2 h0l | Some (), h1l -> match reify (interpret_com_st c1 h0r) h0r with | None, _ -> seq_nil1 c1 c2 h0r | Some (), h1r -> match reify (interpret_com_st c2 h1l) h1l with | None, _ -> seq_nil2 c1 c2 h0l h1l | Some (), h2l -> match reify (interpret_com_st c2 h1r) h1r with | None, _ -> seq_nil2 c1 c2 h0r h1r | Some (), h2r -> let h1 = R h1l h1r in use_ni_com env c1 l h0; assert (low_equiv env h1) ; let h2 = R h2l h2r in use_ni_com env c2 l h1; assert (low_equiv env h2) end val seq_com : env:label_fun -> c1:com -> c2:com -> l:label -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (ni_com env (Seq c1 c2) l)) let seq_com env c1 c2 l = forall_intro (fun (h0:rel heap) -> seq_com' env c1 c2 l h0 <: Lemma (ni_com' env (Seq c1 c2) l h0)) ; forall_intro (fun (h0:heap) -> seq_inv_com' env c1 c2 l h0 <: Lemma (inv_com' env (Seq c1 c2) l h0)) (* Typing rule for conditional commands env |- e : l env,pc:l |- ct env,pc:l |- cf ---------------------------------------------- env,pc:l |- if e <> 0 then ct else cf *) (* let project_inv_com' (env:label_fun) (c:com) (l:label) (h0:heap) : Lemma (requires (ni_com env c l)) (ensures (inv_com' env c l h0)) = () *) val cond_inv_com' : env:label_fun -> e:exp -> ct:com -> cf:com -> l:label -> h0:heap -> Lemma (requires ((ni_exp env e l) /\ (ni_com env ct l) /\ (ni_com env cf l))) (ensures (inv_com' env (If e ct cf) l h0)) let cond_inv_com' env e ct cf l h0 = let v = reify (interpret_exp_st e) h0 in if v = 0 then assert (inv_com' env cf l h0 ==> inv_com' env (If e ct cf) l h0) else assert (inv_com' env ct l h0 ==> inv_com' env (If e ct cf) l h0) (* Works too but takes 20s more *) (* let c = if v = 0 then cf else ct in *) (* match reify (interpret_com_st c h0) h0 with *) (* | None, _ -> () *) (* | Some (), h1 -> () *) #reset-options "--max_fuel 1" let interpret_cond (e:exp) (ct:com) (cf:com) (h:heap) : Lemma (let v = reify (interpret_exp_st e) h in let c = if v = 0 then cf else ct in (reify (interpret_com_st (If e ct cf) h) h == reify (interpret_com_st c h) h)) = () val cond_ni_com' : env:label_fun -> e:exp -> ct:com -> cf:com -> l:label -> h0:rel heap -> Lemma (requires ((ni_exp env e l) /\ (ni_com env ct l) /\ (ni_com env cf l))) (ensures (ni_com' env (If e ct cf) l h0)) let cond_ni_com' env e ct cf l h0 = if not (FStar.StrongExcludedMiddle.strong_excluded_middle (low_equiv env h0)) then () else let R h0l h0r = h0 in let vl = reify (interpret_exp_st e) h0l in let vr = reify (interpret_exp_st e) h0r in if Low? l then begin assert (vl == vr) ; let c = if vl = 0 then cf else ct in assert (ni_com env c l) ; let cif = If e ct cf in //NS:05/15 ... this 2 should be trivial to prove. // Why do they require a lemma? interpret_cond e ct cf h0l; interpret_cond e ct cf h0r; use_ni_com env c l (R h0l h0r) end else (* h0 and h1 are low_equiv since cl and cr cannot write at low cells *) match reify (interpret_com_st (If e ct cf) h0l) h0l with | None, _ -> () | Some (), h1l -> match reify (interpret_com_st (If e ct cf) h0r) h0r with | None, _ -> () | Some (), h1r -> cond_inv_com' env e ct cf l h0l ; cond_inv_com' env e ct cf l h0r ; assert (low_equiv env h0 ==> low_equiv env (R h1l h1r)) #set-options "--z3rlimit 5" val cond_com : env:label_fun -> e:exp -> ct:com -> cf:com -> l:label -> Lemma (requires ((ni_exp env e l) /\ (ni_com env ct l) /\ (ni_com env cf l))) (ensures (ni_com env (If e ct cf) l)) let cond_com env e ct cf l = forall_intro (fun (h0:rel heap) -> cond_ni_com' env e ct cf l h0 <: Lemma (ni_com' env (If e ct cf) l h0)) ; forall_intro (fun (h0:heap) -> cond_inv_com' env e ct cf l h0 <: Lemma (inv_com' env (If e ct cf) l h0)) (* Typing rule for Skip ------------------- env,pc:High |- skip *) val skip_com : env:label_fun -> Lemma (ni_com env Skip High) let skip_com _ = () (* While rule for commands env |- e : l env,pc:l |- c ----------------------------------- env,pc:l |- while (e <> 0) do c *) val while_inv_com' : env:label_fun -> e:exp -> c:com -> v:metric -> l:label -> h0:heap -> Lemma (requires (ni_exp env e l /\ ni_com env c l)) (ensures (inv_com' env (While e c v) l h0)) (decreases (decr_while h0 (While e c v))) #reset-options "--z3rlimit 40" let interpret_while_nil e c v h : Lemma (requires (reify (interpret_exp_st e) h <> 0 /\ fst (reify (interpret_com_st c h) h) == None)) (ensures (interpret_com h (While e c v) == None)) = () let interpret_while_loops (e:exp) (c:com) (v:metric) (h:heap) : Lemma (requires (reify (interpret_exp_st e) h <> 0 /\ (match reify (interpret_com_st c h) h with | None, _ -> True | Some _, h' -> interpret_exp' h' v >= interpret_exp' h v))) (ensures (interpret_com h (While e c v) == None)) = () let rec while_inv_com' env e c v l h0 = let v0 = reify (interpret_exp_st e) h0 in if v0 = 0 then assert (interpret_com h0 (While e c v) == Some h0) else let m0 = interpret_exp' h0 v in match reify (interpret_com_st c h0) h0 with | None, _ -> interpret_while_nil e c v h0 | Some (), h2 -> let m1 = interpret_exp' h2 v in if m0 > m1 then begin assert (decr_while h2 (While e c v) << decr_while h0 (While e c v)) ; while_inv_com' env e c v l h2 end else interpret_while_loops e c v h0 val while_ni_com'_low_equiv_high : env:label_fun -> e:exp -> c:com -> v:metric -> l:label -> h0:rel heap -> Lemma (requires (ni_exp env e l /\ ni_com env c l /\ low_equiv env h0 /\ High? l)) (ensures (ni_com' env (While e c v) l h0)) let while_ni_com'_low_equiv_high env e c v l h0 = (* h0 and h1 are low_equiv since cl and cr cannot write at low cells *) let R h0l h0r = h0 in match reify (interpret_com_st (While e c v) h0l) h0l with | None, _ -> () | Some (), h1l -> match reify (interpret_com_st (While e c v) h0r) h0r with | None, _ -> () | Some (), h1r -> while_inv_com' env e c v l h0l ; while_inv_com' env e c v l h0r ; assert (low_equiv env h0 ==> low_equiv env (R h1l h1r)) val while_ni_com'_low_equiv_low : env:label_fun -> e:exp -> c:com -> v:metric -> l:label -> h0:rel heap -> Lemma (requires (ni_exp env e l /\ ni_com env c l /\ low_equiv env h0 /\ Low? l)) (ensures (ni_com' env (While e c v) l h0)) (decreases (decr_while (R?.l h0) (While e c v) + decr_while (R?.r h0) (While e c v))) let rec while_ni_com'_low_equiv_low env e c v l h0 = let R h0l h0r = h0 in let v0l = reify (interpret_exp_st e) h0l in let v0r = reify (interpret_exp_st e) h0r in assert (v0l == v0r) ; if v0l = 0 then begin assert (interpret_com h0l (While e c v) == Some h0l); assert (interpret_com h0r (While e c v) == Some h0r) end else let m0l = interpret_exp' h0l v in let m0r = interpret_exp' h0r v in match reify (interpret_com_st c h0l) h0l with | None, _ -> interpret_while_nil e c v h0l | Some (), h2l -> match reify (interpret_com_st c h0r) h0r with | None, _ -> interpret_while_nil e c v h0r | Some (), h2r -> let m1l = interpret_exp' h2l v in let m1r = interpret_exp' h2r v in if m0l > m1l then if m0r > m1r then begin assert (decr_while h2l (While e c v) << decr_while h0l (While e c v)) ; while_ni_com'_low_equiv_low env e c v l (R h2l h2r) end else interpret_while_loops e c v h0r else interpret_while_loops e c v h0l val while_ni_com' : env:label_fun -> e:exp -> c:com -> v:metric -> l:label -> h0:rel heap -> Lemma (requires (ni_exp env e l /\ ni_com env c l)) (ensures (ni_com' env (While e c v) l h0)) #set-options "--max_fuel 1 --max_ifuel 1 --z3rlimit 50" let while_ni_com' env e c v l h0 = if not (FStar.StrongExcludedMiddle.strong_excluded_middle (low_equiv env h0)) then () else if Low? l then while_ni_com'_low_equiv_low env e c v l h0 else while_ni_com'_low_equiv_high env e c v l h0 #set-options "--z3rlimit 5" val while_com : env:label_fun -> e:exp -> c:com -> v:metric -> l:label -> Lemma (requires (ni_exp env e l /\ ni_com env c l))

env: IfcRulesReify.label_fun -> e: WhileReify.exp -> c: WhileReify.com -> v: WhileReify.metric -> l: IfcRulesReify.label -> FStar.Pervasives.Lemma (requires IfcRulesReify.ni_exp env e l /\ IfcRulesReify.ni_com env c l) (ensures IfcRulesReify.ni_com env (WhileReify.While e c v) l)

FStar.Pervasives.Lemma

let while_com env e c v l =

forall_intro (fun (h: rel heap) -> while_ni_com' env e c v l h <: Lemma (ensures (ni_com' env (While e c v) l h))); forall_intro (fun (h0: heap) -> while_inv_com' env e c v l h0 <: Lemma (ensures (inv_com' env (While e c v) l h0)))

IfcRulesReify.fst

IfcRulesReify.cond_ni_com'

val cond_ni_com' : env:label_fun -> e:exp -> ct:com -> cf:com -> l:label -> h0:rel heap -> Lemma (requires ((ni_exp env e l) /\ (ni_com env ct l) /\ (ni_com env cf l))) (ensures (ni_com' env (If e ct cf) l h0))

val cond_ni_com' : env:label_fun -> e:exp -> ct:com -> cf:com -> l:label -> h0:rel heap -> Lemma (requires ((ni_exp env e l) /\ (ni_com env ct l) /\ (ni_com env cf l))) (ensures (ni_com' env (If e ct cf) l h0))

let cond_ni_com' env e ct cf l h0 = if not (FStar.StrongExcludedMiddle.strong_excluded_middle (low_equiv env h0)) then () else let R h0l h0r = h0 in let vl = reify (interpret_exp_st e) h0l in let vr = reify (interpret_exp_st e) h0r in if Low? l then begin assert (vl == vr) ; let c = if vl = 0 then cf else ct in assert (ni_com env c l) ; let cif = If e ct cf in //NS:05/15 ... this 2 should be trivial to prove. // Why do they require a lemma? interpret_cond e ct cf h0l; interpret_cond e ct cf h0r; use_ni_com env c l (R h0l h0r) end else (* h0 and h1 are low_equiv since cl and cr cannot write at low cells *) match reify (interpret_com_st (If e ct cf) h0l) h0l with | None, _ -> () | Some (), h1l -> match reify (interpret_com_st (If e ct cf) h0r) h0r with | None, _ -> () | Some (), h1r -> cond_inv_com' env e ct cf l h0l ; cond_inv_com' env e ct cf l h0r ; assert (low_equiv env h0 ==> low_equiv env (R h1l h1r))

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module IfcRulesReify open Rel open WhileReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreExcFixed open FStar.Squash open FStar.Classical (****************************** Preliminaries ******************************) (* CH: Everything specialized to 2-point lattice *) type label = | Low | High val op_Less : label -> label -> Tot bool let op_Less l1 l2 = match l1, l2 with | Low,High -> true | _, _ -> false val op_Less_Equals : label -> label -> Tot bool let op_Less_Equals l1 l2 = match l1, l2 with | High,Low -> false | _, _ -> true val join : label -> label -> Tot label let join l1 l2 = match l1, l2 with | Low,Low -> Low | _, _ -> High val meet : label -> label -> Tot label let meet l1 l2 = match l1, l2 with | High, High -> High | _, _ -> Low let universal_property_meet l l1 l2 : Lemma (requires (l <= l1 /\ l <= l2)) (ensures (l <= meet l1 l2)) = () type label_fun = id -> Tot label type low_equiv (env:label_fun) (h1:rel heap) = (forall (x:id). (* {:pattern (env x)} *) env x = Low ==> index (R?.l h1) x = index (R?.r h1) x) (**************************** Typing Judgements ****************************) (* env |- e : l - Expressions do not modify the heap - Correctness - Low equivalent input heaps + Low label ==> same result *) let ni_exp (env:label_fun) (e:exp) (l:label) : Tot Type0 = forall (h: rel heap). (* {:pattern (low_equiv env h)} *) (low_equiv env h /\ Low? l) ==> (* interpret_exp (R?.r h) e = interpret_exp (R?.l h) e *) begin let vr = reify (interpret_exp_st e) (R?.r h)in let vl = reify (interpret_exp_st e) (R?.l h) in vr = vl end (* env,pc:l |- c - References with a label below l are not modified - Total correctness - Low equivalent input heaps ==> Low equivalent output heaps *) let inv_com' (env:label_fun) (c:com) (l:label) (h0:heap) : Tot Type0 = match interpret_com h0 c with | None -> True | Some h1 -> forall (i:id). (* {:pattern (env i < l)} *) env i < l ==> index h0 i = index h1 i let ni_com' (env:label_fun) (c:com) (l:label) (h0:rel heap) : Tot Type0 = let R h0l h0r = h0 in (* KM : That's the code that we would like to write but subtyping and matching on pairs interplay badly *) (* it generates a VC which boils down to [forall (h1l:heap). length h1l = length h0l] which is obviously false *) (* begin match interpret_com h0l c, interpret_com h0r c with *) (* | Some h1l, Some h1r -> low_equiv env (R h0l h0r) ==> low_equiv env (R h1l h1r) *) (* | _ -> True *) (* end *) begin match interpret_com h0l c with | Some h1l -> begin match interpret_com h0r c with | Some h1r -> low_equiv env h0 ==> low_equiv env (R h1l h1r) | _ -> True end | _ -> True end let ni_com (env:label_fun) (c:com) (l:label) : Tot Type0 = (forall (h0: rel heap). (* {:pattern (low_equiv env h0)} *) ni_com' env c l h0) /\ (forall (h0:heap). (* {:pattern (Some? (interpret_com h0 c))} *) inv_com' env c l h0) (*********************** Typing Rules for Expressions **********************) (* CH: The way we derive these rules looks more like a semantically-justified program logic than a syntactic type system. Any connection to Dave Naumann and Anindya Banerjee's "relational logic"? (e.g. https://arxiv.org/abs/1611.08992) *) (* Subtyping rule for expression labels E |- e : l1 l1 <= l2 ---------------------- E |- e : l2 *) val sub_exp : env:label_fun -> e:exp -> l1:label -> l2:label -> Lemma (requires (l1 <= l2 /\ ni_exp env e l1)) (ensures (ni_exp env e l2)) let sub_exp _ _ _ _ = () (* Typing rule for dereferencing ---------------- E | - r : E(r) *) val avar_exp : env:label_fun -> r:id -> Lemma (ensures (ni_exp env (AVar r) (env r))) let avar_exp _ _ = () (* Typing rule for Int constants i : int ------- i : Low *) val aint_exp : env:label_fun -> i:int -> Lemma (requires True) (ensures (ni_exp env (AInt i) Low)) let aint_exp _ _ = () (* Typing rule for binary operators e1 : l e2 : l ---------------- e1 `op` e2 : l *) val binop_exp : env:label_fun -> op:binop -> e1:exp -> e2:exp -> l:label -> Lemma (requires (ni_exp env e1 l) /\ (ni_exp env e2 l)) (ensures (ni_exp env (AOp op e1 e2) l)) let binop_exp env op e1 e2 l = () (************************ Typing Rules for Commands ************************) (* Subtyping rule for commands env,pc:l1 |- c l2 <= l1 --------------------------- env,pc:l2 |- c *) val sub_com : env:label_fun -> c:com -> l1:label -> l2:label -> Lemma (requires (l2 <= l1 /\ ni_com env c l1 )) (ensures (ni_com env c l2 )) let sub_com _ _ _ _ = () (* Typing rule for assignment env |- e : env(r) ------------------------ env, pc:env(r) |- r := e - label of expression and context label have to be below label of r (first one to prevent explicit, second to prevent implicit flows) *) let assign_inv_com0 (env:label_fun) (e:exp) (r:id) (ne:squash(ni_exp env e (env r))) (h0:rel heap) : Lemma (ni_com' env (Assign r e) (env r) h0) = FStar.Squash.give_proof ne ; let vr = reify (interpret_exp_st e) (R?.r h0) in let vl = reify (interpret_exp_st e) (R?.l h0) in match reify (interpret_com_st (Assign r e) (R?.l h0)) (R?.l h0) with | Some (), h1l -> begin match reify (interpret_com_st (Assign r e) (R?.r h0)) (R?.r h0) with | Some (), h1r -> assert (h1l = upd (R?.l h0) r vl /\ h1r = upd (R?.r h0) r vr) | None, _ -> () end | None, _ -> () let assign_inv_com' (env:label_fun) (e:exp) (r:id) (h0:heap) : Lemma (inv_com' env (Assign r e) (env r) h0) = let v = reify (interpret_exp_st e) h0 in match reify (interpret_com_st (Assign r e) h0) h0 with | None, h1 -> () | Some (), h1 -> assert (h1 == upd h0 r v) val assign_com : env:label_fun -> e:exp -> r:id -> Lemma (requires (ni_exp env e (env r))) (ensures (ni_com env (Assign r e) (env r))) let assign_com env e r = forall_intro (assign_inv_com0 env e r (FStar.Squash.get_proof (ni_exp env e (env r)))) ; forall_intro (assign_inv_com' env e r) let seq_nil1 (c1:com) (c2:com) (h:heap) : Lemma (requires (fst (reify (interpret_com_st c1 h) h) = None)) (ensures (fst (reify (interpret_com_st (Seq c1 c2) h) h) = None)) = () let seq_nil2 (c1:com) (c2:com) (h0:heap) (h1:heap) : Lemma (requires (h1 == snd (reify (interpret_com_st c1 h0) h0) /\ fst (reify (interpret_com_st c2 h1) h1) = None)) (ensures (fst (reify (interpret_com_st (Seq c1 c2) h0) h0) = None)) = () (* Sequencing rule for commands env,pc:l |- c1 env,pc:l |- c2 ------------------------------ env,pc:l |- c1; c2 *) val seq_inv_com' : env:label_fun -> c1:com -> c2:com -> l:label -> h0:heap -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (inv_com' env (Seq c1 c2) l h0)) let seq_inv_com' env c1 c2 l h0 = match reify (interpret_com_st c1 h0) h0 with | None, _ -> seq_nil1 c1 c2 h0 | Some (), h1 -> match reify (interpret_com_st c2 h1) h1 with | None, _ -> seq_nil2 c1 c2 h0 h1 | Some (), h2 -> () #set-options "--z3rlimit 50" let use_ni_com (env:label_fun) (c:com) (l:label) (h:rel heap{low_equiv env h}) : Lemma (requires ni_com env c l) (ensures (let R hl hr = h in match reify (interpret_com_st c hl) hl, reify (interpret_com_st c hr) hr with | (Some _, hl'), (Some _, hr') -> low_equiv env (R hl' hr') | _ -> True)) = () val seq_com' : env:label_fun -> c1:com -> c2:com -> l:label -> h0: rel heap -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (ni_com' env (Seq c1 c2) l h0)) let seq_com' env c1 c2 l h0 = if not (FStar.StrongExcludedMiddle.strong_excluded_middle (low_equiv env h0)) then () else begin assert (low_equiv env h0); let R h0l h0r = h0 in match reify (interpret_com_st c1 h0l) h0l with | None, _ -> seq_nil1 c1 c2 h0l | Some (), h1l -> match reify (interpret_com_st c1 h0r) h0r with | None, _ -> seq_nil1 c1 c2 h0r | Some (), h1r -> match reify (interpret_com_st c2 h1l) h1l with | None, _ -> seq_nil2 c1 c2 h0l h1l | Some (), h2l -> match reify (interpret_com_st c2 h1r) h1r with | None, _ -> seq_nil2 c1 c2 h0r h1r | Some (), h2r -> let h1 = R h1l h1r in use_ni_com env c1 l h0; assert (low_equiv env h1) ; let h2 = R h2l h2r in use_ni_com env c2 l h1; assert (low_equiv env h2) end val seq_com : env:label_fun -> c1:com -> c2:com -> l:label -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (ni_com env (Seq c1 c2) l)) let seq_com env c1 c2 l = forall_intro (fun (h0:rel heap) -> seq_com' env c1 c2 l h0 <: Lemma (ni_com' env (Seq c1 c2) l h0)) ; forall_intro (fun (h0:heap) -> seq_inv_com' env c1 c2 l h0 <: Lemma (inv_com' env (Seq c1 c2) l h0)) (* Typing rule for conditional commands env |- e : l env,pc:l |- ct env,pc:l |- cf ---------------------------------------------- env,pc:l |- if e <> 0 then ct else cf *) (* let project_inv_com' (env:label_fun) (c:com) (l:label) (h0:heap) : Lemma (requires (ni_com env c l)) (ensures (inv_com' env c l h0)) = () *) val cond_inv_com' : env:label_fun -> e:exp -> ct:com -> cf:com -> l:label -> h0:heap -> Lemma (requires ((ni_exp env e l) /\ (ni_com env ct l) /\ (ni_com env cf l))) (ensures (inv_com' env (If e ct cf) l h0)) let cond_inv_com' env e ct cf l h0 = let v = reify (interpret_exp_st e) h0 in if v = 0 then assert (inv_com' env cf l h0 ==> inv_com' env (If e ct cf) l h0) else assert (inv_com' env ct l h0 ==> inv_com' env (If e ct cf) l h0) (* Works too but takes 20s more *) (* let c = if v = 0 then cf else ct in *) (* match reify (interpret_com_st c h0) h0 with *) (* | None, _ -> () *) (* | Some (), h1 -> () *) #reset-options "--max_fuel 1" let interpret_cond (e:exp) (ct:com) (cf:com) (h:heap) : Lemma (let v = reify (interpret_exp_st e) h in let c = if v = 0 then cf else ct in (reify (interpret_com_st (If e ct cf) h) h == reify (interpret_com_st c h) h)) = () val cond_ni_com' : env:label_fun -> e:exp -> ct:com -> cf:com -> l:label -> h0:rel heap -> Lemma (requires ((ni_exp env e l) /\ (ni_com env ct l) /\ (ni_com env cf l)))

env: IfcRulesReify.label_fun -> e: WhileReify.exp -> ct: WhileReify.com -> cf: WhileReify.com -> l: IfcRulesReify.label -> h0: Rel.rel FStar.DM4F.Heap.IntStoreFixed.heap -> FStar.Pervasives.Lemma (requires IfcRulesReify.ni_exp env e l /\ IfcRulesReify.ni_com env ct l /\ IfcRulesReify.ni_com env cf l) (ensures IfcRulesReify.ni_com' env (WhileReify.If e ct cf) l h0)

FStar.Pervasives.Lemma

let cond_ni_com' env e ct cf l h0 =

if not (FStar.StrongExcludedMiddle.strong_excluded_middle (low_equiv env h0)) then () else let R h0l h0r = h0 in let vl = reify (interpret_exp_st e) h0l in let vr = reify (interpret_exp_st e) h0r in if Low? l then (assert (vl == vr); let c = if vl = 0 then cf else ct in assert (ni_com env c l); let cif = If e ct cf in interpret_cond e ct cf h0l; interpret_cond e ct cf h0r; use_ni_com env c l (R h0l h0r)) else match reify (interpret_com_st (If e ct cf) h0l) h0l with | None, _ -> () | Some (), h1l -> match reify (interpret_com_st (If e ct cf) h0r) h0r with | None, _ -> () | Some (), h1r -> cond_inv_com' env e ct cf l h0l; cond_inv_com' env e ct cf l h0r; assert (low_equiv env h0 ==> low_equiv env (R h1l h1r))

IfcRulesReify.fst

IfcRulesReify.seq_com'

val seq_com' : env:label_fun -> c1:com -> c2:com -> l:label -> h0: rel heap -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (ni_com' env (Seq c1 c2) l h0))

val seq_com' : env:label_fun -> c1:com -> c2:com -> l:label -> h0: rel heap -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (ni_com' env (Seq c1 c2) l h0))

let seq_com' env c1 c2 l h0 = if not (FStar.StrongExcludedMiddle.strong_excluded_middle (low_equiv env h0)) then () else begin assert (low_equiv env h0); let R h0l h0r = h0 in match reify (interpret_com_st c1 h0l) h0l with | None, _ -> seq_nil1 c1 c2 h0l | Some (), h1l -> match reify (interpret_com_st c1 h0r) h0r with | None, _ -> seq_nil1 c1 c2 h0r | Some (), h1r -> match reify (interpret_com_st c2 h1l) h1l with | None, _ -> seq_nil2 c1 c2 h0l h1l | Some (), h2l -> match reify (interpret_com_st c2 h1r) h1r with | None, _ -> seq_nil2 c1 c2 h0r h1r | Some (), h2r -> let h1 = R h1l h1r in use_ni_com env c1 l h0; assert (low_equiv env h1) ; let h2 = R h2l h2r in use_ni_com env c2 l h1; assert (low_equiv env h2) end

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module IfcRulesReify open Rel open WhileReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreExcFixed open FStar.Squash open FStar.Classical (****************************** Preliminaries ******************************) (* CH: Everything specialized to 2-point lattice *) type label = | Low | High val op_Less : label -> label -> Tot bool let op_Less l1 l2 = match l1, l2 with | Low,High -> true | _, _ -> false val op_Less_Equals : label -> label -> Tot bool let op_Less_Equals l1 l2 = match l1, l2 with | High,Low -> false | _, _ -> true val join : label -> label -> Tot label let join l1 l2 = match l1, l2 with | Low,Low -> Low | _, _ -> High val meet : label -> label -> Tot label let meet l1 l2 = match l1, l2 with | High, High -> High | _, _ -> Low let universal_property_meet l l1 l2 : Lemma (requires (l <= l1 /\ l <= l2)) (ensures (l <= meet l1 l2)) = () type label_fun = id -> Tot label type low_equiv (env:label_fun) (h1:rel heap) = (forall (x:id). (* {:pattern (env x)} *) env x = Low ==> index (R?.l h1) x = index (R?.r h1) x) (**************************** Typing Judgements ****************************) (* env |- e : l - Expressions do not modify the heap - Correctness - Low equivalent input heaps + Low label ==> same result *) let ni_exp (env:label_fun) (e:exp) (l:label) : Tot Type0 = forall (h: rel heap). (* {:pattern (low_equiv env h)} *) (low_equiv env h /\ Low? l) ==> (* interpret_exp (R?.r h) e = interpret_exp (R?.l h) e *) begin let vr = reify (interpret_exp_st e) (R?.r h)in let vl = reify (interpret_exp_st e) (R?.l h) in vr = vl end (* env,pc:l |- c - References with a label below l are not modified - Total correctness - Low equivalent input heaps ==> Low equivalent output heaps *) let inv_com' (env:label_fun) (c:com) (l:label) (h0:heap) : Tot Type0 = match interpret_com h0 c with | None -> True | Some h1 -> forall (i:id). (* {:pattern (env i < l)} *) env i < l ==> index h0 i = index h1 i let ni_com' (env:label_fun) (c:com) (l:label) (h0:rel heap) : Tot Type0 = let R h0l h0r = h0 in (* KM : That's the code that we would like to write but subtyping and matching on pairs interplay badly *) (* it generates a VC which boils down to [forall (h1l:heap). length h1l = length h0l] which is obviously false *) (* begin match interpret_com h0l c, interpret_com h0r c with *) (* | Some h1l, Some h1r -> low_equiv env (R h0l h0r) ==> low_equiv env (R h1l h1r) *) (* | _ -> True *) (* end *) begin match interpret_com h0l c with | Some h1l -> begin match interpret_com h0r c with | Some h1r -> low_equiv env h0 ==> low_equiv env (R h1l h1r) | _ -> True end | _ -> True end let ni_com (env:label_fun) (c:com) (l:label) : Tot Type0 = (forall (h0: rel heap). (* {:pattern (low_equiv env h0)} *) ni_com' env c l h0) /\ (forall (h0:heap). (* {:pattern (Some? (interpret_com h0 c))} *) inv_com' env c l h0) (*********************** Typing Rules for Expressions **********************) (* CH: The way we derive these rules looks more like a semantically-justified program logic than a syntactic type system. Any connection to Dave Naumann and Anindya Banerjee's "relational logic"? (e.g. https://arxiv.org/abs/1611.08992) *) (* Subtyping rule for expression labels E |- e : l1 l1 <= l2 ---------------------- E |- e : l2 *) val sub_exp : env:label_fun -> e:exp -> l1:label -> l2:label -> Lemma (requires (l1 <= l2 /\ ni_exp env e l1)) (ensures (ni_exp env e l2)) let sub_exp _ _ _ _ = () (* Typing rule for dereferencing ---------------- E | - r : E(r) *) val avar_exp : env:label_fun -> r:id -> Lemma (ensures (ni_exp env (AVar r) (env r))) let avar_exp _ _ = () (* Typing rule for Int constants i : int ------- i : Low *) val aint_exp : env:label_fun -> i:int -> Lemma (requires True) (ensures (ni_exp env (AInt i) Low)) let aint_exp _ _ = () (* Typing rule for binary operators e1 : l e2 : l ---------------- e1 `op` e2 : l *) val binop_exp : env:label_fun -> op:binop -> e1:exp -> e2:exp -> l:label -> Lemma (requires (ni_exp env e1 l) /\ (ni_exp env e2 l)) (ensures (ni_exp env (AOp op e1 e2) l)) let binop_exp env op e1 e2 l = () (************************ Typing Rules for Commands ************************) (* Subtyping rule for commands env,pc:l1 |- c l2 <= l1 --------------------------- env,pc:l2 |- c *) val sub_com : env:label_fun -> c:com -> l1:label -> l2:label -> Lemma (requires (l2 <= l1 /\ ni_com env c l1 )) (ensures (ni_com env c l2 )) let sub_com _ _ _ _ = () (* Typing rule for assignment env |- e : env(r) ------------------------ env, pc:env(r) |- r := e - label of expression and context label have to be below label of r (first one to prevent explicit, second to prevent implicit flows) *) let assign_inv_com0 (env:label_fun) (e:exp) (r:id) (ne:squash(ni_exp env e (env r))) (h0:rel heap) : Lemma (ni_com' env (Assign r e) (env r) h0) = FStar.Squash.give_proof ne ; let vr = reify (interpret_exp_st e) (R?.r h0) in let vl = reify (interpret_exp_st e) (R?.l h0) in match reify (interpret_com_st (Assign r e) (R?.l h0)) (R?.l h0) with | Some (), h1l -> begin match reify (interpret_com_st (Assign r e) (R?.r h0)) (R?.r h0) with | Some (), h1r -> assert (h1l = upd (R?.l h0) r vl /\ h1r = upd (R?.r h0) r vr) | None, _ -> () end | None, _ -> () let assign_inv_com' (env:label_fun) (e:exp) (r:id) (h0:heap) : Lemma (inv_com' env (Assign r e) (env r) h0) = let v = reify (interpret_exp_st e) h0 in match reify (interpret_com_st (Assign r e) h0) h0 with | None, h1 -> () | Some (), h1 -> assert (h1 == upd h0 r v) val assign_com : env:label_fun -> e:exp -> r:id -> Lemma (requires (ni_exp env e (env r))) (ensures (ni_com env (Assign r e) (env r))) let assign_com env e r = forall_intro (assign_inv_com0 env e r (FStar.Squash.get_proof (ni_exp env e (env r)))) ; forall_intro (assign_inv_com' env e r) let seq_nil1 (c1:com) (c2:com) (h:heap) : Lemma (requires (fst (reify (interpret_com_st c1 h) h) = None)) (ensures (fst (reify (interpret_com_st (Seq c1 c2) h) h) = None)) = () let seq_nil2 (c1:com) (c2:com) (h0:heap) (h1:heap) : Lemma (requires (h1 == snd (reify (interpret_com_st c1 h0) h0) /\ fst (reify (interpret_com_st c2 h1) h1) = None)) (ensures (fst (reify (interpret_com_st (Seq c1 c2) h0) h0) = None)) = () (* Sequencing rule for commands env,pc:l |- c1 env,pc:l |- c2 ------------------------------ env,pc:l |- c1; c2 *) val seq_inv_com' : env:label_fun -> c1:com -> c2:com -> l:label -> h0:heap -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (inv_com' env (Seq c1 c2) l h0)) let seq_inv_com' env c1 c2 l h0 = match reify (interpret_com_st c1 h0) h0 with | None, _ -> seq_nil1 c1 c2 h0 | Some (), h1 -> match reify (interpret_com_st c2 h1) h1 with | None, _ -> seq_nil2 c1 c2 h0 h1 | Some (), h2 -> () #set-options "--z3rlimit 50" let use_ni_com (env:label_fun) (c:com) (l:label) (h:rel heap{low_equiv env h}) : Lemma (requires ni_com env c l) (ensures (let R hl hr = h in match reify (interpret_com_st c hl) hl, reify (interpret_com_st c hr) hr with | (Some _, hl'), (Some _, hr') -> low_equiv env (R hl' hr') | _ -> True)) = () val seq_com' : env:label_fun -> c1:com -> c2:com -> l:label -> h0: rel heap -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l))

env: IfcRulesReify.label_fun -> c1: WhileReify.com -> c2: WhileReify.com -> l: IfcRulesReify.label -> h0: Rel.rel FStar.DM4F.Heap.IntStoreFixed.heap -> FStar.Pervasives.Lemma (requires IfcRulesReify.ni_com env c1 l /\ IfcRulesReify.ni_com env c2 l) (ensures IfcRulesReify.ni_com' env (WhileReify.Seq c1 c2) l h0)

FStar.Pervasives.Lemma

let seq_com' env c1 c2 l h0 =

if not (FStar.StrongExcludedMiddle.strong_excluded_middle (low_equiv env h0)) then () else (assert (low_equiv env h0); let R h0l h0r = h0 in match reify (interpret_com_st c1 h0l) h0l with | None, _ -> seq_nil1 c1 c2 h0l | Some (), h1l -> match reify (interpret_com_st c1 h0r) h0r with | None, _ -> seq_nil1 c1 c2 h0r | Some (), h1r -> match reify (interpret_com_st c2 h1l) h1l with | None, _ -> seq_nil2 c1 c2 h0l h1l | Some (), h2l -> match reify (interpret_com_st c2 h1r) h1r with | None, _ -> seq_nil2 c1 c2 h0r h1r | Some (), h2r -> let h1 = R h1l h1r in use_ni_com env c1 l h0; assert (low_equiv env h1); let h2 = R h2l h2r in use_ni_com env c2 l h1; assert (low_equiv env h2))

IfcRulesReify.fst

IfcRulesReify.while_ni_com'

val while_ni_com' : env:label_fun -> e:exp -> c:com -> v:metric -> l:label -> h0:rel heap -> Lemma (requires (ni_exp env e l /\ ni_com env c l)) (ensures (ni_com' env (While e c v) l h0))

val while_ni_com' : env:label_fun -> e:exp -> c:com -> v:metric -> l:label -> h0:rel heap -> Lemma (requires (ni_exp env e l /\ ni_com env c l)) (ensures (ni_com' env (While e c v) l h0))

let while_ni_com' env e c v l h0 = if not (FStar.StrongExcludedMiddle.strong_excluded_middle (low_equiv env h0)) then () else if Low? l then while_ni_com'_low_equiv_low env e c v l h0 else while_ni_com'_low_equiv_high env e c v l h0

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module IfcRulesReify open Rel open WhileReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreExcFixed open FStar.Squash open FStar.Classical (****************************** Preliminaries ******************************) (* CH: Everything specialized to 2-point lattice *) type label = | Low | High val op_Less : label -> label -> Tot bool let op_Less l1 l2 = match l1, l2 with | Low,High -> true | _, _ -> false val op_Less_Equals : label -> label -> Tot bool let op_Less_Equals l1 l2 = match l1, l2 with | High,Low -> false | _, _ -> true val join : label -> label -> Tot label let join l1 l2 = match l1, l2 with | Low,Low -> Low | _, _ -> High val meet : label -> label -> Tot label let meet l1 l2 = match l1, l2 with | High, High -> High | _, _ -> Low let universal_property_meet l l1 l2 : Lemma (requires (l <= l1 /\ l <= l2)) (ensures (l <= meet l1 l2)) = () type label_fun = id -> Tot label type low_equiv (env:label_fun) (h1:rel heap) = (forall (x:id). (* {:pattern (env x)} *) env x = Low ==> index (R?.l h1) x = index (R?.r h1) x) (**************************** Typing Judgements ****************************) (* env |- e : l - Expressions do not modify the heap - Correctness - Low equivalent input heaps + Low label ==> same result *) let ni_exp (env:label_fun) (e:exp) (l:label) : Tot Type0 = forall (h: rel heap). (* {:pattern (low_equiv env h)} *) (low_equiv env h /\ Low? l) ==> (* interpret_exp (R?.r h) e = interpret_exp (R?.l h) e *) begin let vr = reify (interpret_exp_st e) (R?.r h)in let vl = reify (interpret_exp_st e) (R?.l h) in vr = vl end (* env,pc:l |- c - References with a label below l are not modified - Total correctness - Low equivalent input heaps ==> Low equivalent output heaps *) let inv_com' (env:label_fun) (c:com) (l:label) (h0:heap) : Tot Type0 = match interpret_com h0 c with | None -> True | Some h1 -> forall (i:id). (* {:pattern (env i < l)} *) env i < l ==> index h0 i = index h1 i let ni_com' (env:label_fun) (c:com) (l:label) (h0:rel heap) : Tot Type0 = let R h0l h0r = h0 in (* KM : That's the code that we would like to write but subtyping and matching on pairs interplay badly *) (* it generates a VC which boils down to [forall (h1l:heap). length h1l = length h0l] which is obviously false *) (* begin match interpret_com h0l c, interpret_com h0r c with *) (* | Some h1l, Some h1r -> low_equiv env (R h0l h0r) ==> low_equiv env (R h1l h1r) *) (* | _ -> True *) (* end *) begin match interpret_com h0l c with | Some h1l -> begin match interpret_com h0r c with | Some h1r -> low_equiv env h0 ==> low_equiv env (R h1l h1r) | _ -> True end | _ -> True end let ni_com (env:label_fun) (c:com) (l:label) : Tot Type0 = (forall (h0: rel heap). (* {:pattern (low_equiv env h0)} *) ni_com' env c l h0) /\ (forall (h0:heap). (* {:pattern (Some? (interpret_com h0 c))} *) inv_com' env c l h0) (*********************** Typing Rules for Expressions **********************) (* CH: The way we derive these rules looks more like a semantically-justified program logic than a syntactic type system. Any connection to Dave Naumann and Anindya Banerjee's "relational logic"? (e.g. https://arxiv.org/abs/1611.08992) *) (* Subtyping rule for expression labels E |- e : l1 l1 <= l2 ---------------------- E |- e : l2 *) val sub_exp : env:label_fun -> e:exp -> l1:label -> l2:label -> Lemma (requires (l1 <= l2 /\ ni_exp env e l1)) (ensures (ni_exp env e l2)) let sub_exp _ _ _ _ = () (* Typing rule for dereferencing ---------------- E | - r : E(r) *) val avar_exp : env:label_fun -> r:id -> Lemma (ensures (ni_exp env (AVar r) (env r))) let avar_exp _ _ = () (* Typing rule for Int constants i : int ------- i : Low *) val aint_exp : env:label_fun -> i:int -> Lemma (requires True) (ensures (ni_exp env (AInt i) Low)) let aint_exp _ _ = () (* Typing rule for binary operators e1 : l e2 : l ---------------- e1 `op` e2 : l *) val binop_exp : env:label_fun -> op:binop -> e1:exp -> e2:exp -> l:label -> Lemma (requires (ni_exp env e1 l) /\ (ni_exp env e2 l)) (ensures (ni_exp env (AOp op e1 e2) l)) let binop_exp env op e1 e2 l = () (************************ Typing Rules for Commands ************************) (* Subtyping rule for commands env,pc:l1 |- c l2 <= l1 --------------------------- env,pc:l2 |- c *) val sub_com : env:label_fun -> c:com -> l1:label -> l2:label -> Lemma (requires (l2 <= l1 /\ ni_com env c l1 )) (ensures (ni_com env c l2 )) let sub_com _ _ _ _ = () (* Typing rule for assignment env |- e : env(r) ------------------------ env, pc:env(r) |- r := e - label of expression and context label have to be below label of r (first one to prevent explicit, second to prevent implicit flows) *) let assign_inv_com0 (env:label_fun) (e:exp) (r:id) (ne:squash(ni_exp env e (env r))) (h0:rel heap) : Lemma (ni_com' env (Assign r e) (env r) h0) = FStar.Squash.give_proof ne ; let vr = reify (interpret_exp_st e) (R?.r h0) in let vl = reify (interpret_exp_st e) (R?.l h0) in match reify (interpret_com_st (Assign r e) (R?.l h0)) (R?.l h0) with | Some (), h1l -> begin match reify (interpret_com_st (Assign r e) (R?.r h0)) (R?.r h0) with | Some (), h1r -> assert (h1l = upd (R?.l h0) r vl /\ h1r = upd (R?.r h0) r vr) | None, _ -> () end | None, _ -> () let assign_inv_com' (env:label_fun) (e:exp) (r:id) (h0:heap) : Lemma (inv_com' env (Assign r e) (env r) h0) = let v = reify (interpret_exp_st e) h0 in match reify (interpret_com_st (Assign r e) h0) h0 with | None, h1 -> () | Some (), h1 -> assert (h1 == upd h0 r v) val assign_com : env:label_fun -> e:exp -> r:id -> Lemma (requires (ni_exp env e (env r))) (ensures (ni_com env (Assign r e) (env r))) let assign_com env e r = forall_intro (assign_inv_com0 env e r (FStar.Squash.get_proof (ni_exp env e (env r)))) ; forall_intro (assign_inv_com' env e r) let seq_nil1 (c1:com) (c2:com) (h:heap) : Lemma (requires (fst (reify (interpret_com_st c1 h) h) = None)) (ensures (fst (reify (interpret_com_st (Seq c1 c2) h) h) = None)) = () let seq_nil2 (c1:com) (c2:com) (h0:heap) (h1:heap) : Lemma (requires (h1 == snd (reify (interpret_com_st c1 h0) h0) /\ fst (reify (interpret_com_st c2 h1) h1) = None)) (ensures (fst (reify (interpret_com_st (Seq c1 c2) h0) h0) = None)) = () (* Sequencing rule for commands env,pc:l |- c1 env,pc:l |- c2 ------------------------------ env,pc:l |- c1; c2 *) val seq_inv_com' : env:label_fun -> c1:com -> c2:com -> l:label -> h0:heap -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (inv_com' env (Seq c1 c2) l h0)) let seq_inv_com' env c1 c2 l h0 = match reify (interpret_com_st c1 h0) h0 with | None, _ -> seq_nil1 c1 c2 h0 | Some (), h1 -> match reify (interpret_com_st c2 h1) h1 with | None, _ -> seq_nil2 c1 c2 h0 h1 | Some (), h2 -> () #set-options "--z3rlimit 50" let use_ni_com (env:label_fun) (c:com) (l:label) (h:rel heap{low_equiv env h}) : Lemma (requires ni_com env c l) (ensures (let R hl hr = h in match reify (interpret_com_st c hl) hl, reify (interpret_com_st c hr) hr with | (Some _, hl'), (Some _, hr') -> low_equiv env (R hl' hr') | _ -> True)) = () val seq_com' : env:label_fun -> c1:com -> c2:com -> l:label -> h0: rel heap -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (ni_com' env (Seq c1 c2) l h0)) let seq_com' env c1 c2 l h0 = if not (FStar.StrongExcludedMiddle.strong_excluded_middle (low_equiv env h0)) then () else begin assert (low_equiv env h0); let R h0l h0r = h0 in match reify (interpret_com_st c1 h0l) h0l with | None, _ -> seq_nil1 c1 c2 h0l | Some (), h1l -> match reify (interpret_com_st c1 h0r) h0r with | None, _ -> seq_nil1 c1 c2 h0r | Some (), h1r -> match reify (interpret_com_st c2 h1l) h1l with | None, _ -> seq_nil2 c1 c2 h0l h1l | Some (), h2l -> match reify (interpret_com_st c2 h1r) h1r with | None, _ -> seq_nil2 c1 c2 h0r h1r | Some (), h2r -> let h1 = R h1l h1r in use_ni_com env c1 l h0; assert (low_equiv env h1) ; let h2 = R h2l h2r in use_ni_com env c2 l h1; assert (low_equiv env h2) end val seq_com : env:label_fun -> c1:com -> c2:com -> l:label -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (ni_com env (Seq c1 c2) l)) let seq_com env c1 c2 l = forall_intro (fun (h0:rel heap) -> seq_com' env c1 c2 l h0 <: Lemma (ni_com' env (Seq c1 c2) l h0)) ; forall_intro (fun (h0:heap) -> seq_inv_com' env c1 c2 l h0 <: Lemma (inv_com' env (Seq c1 c2) l h0)) (* Typing rule for conditional commands env |- e : l env,pc:l |- ct env,pc:l |- cf ---------------------------------------------- env,pc:l |- if e <> 0 then ct else cf *) (* let project_inv_com' (env:label_fun) (c:com) (l:label) (h0:heap) : Lemma (requires (ni_com env c l)) (ensures (inv_com' env c l h0)) = () *) val cond_inv_com' : env:label_fun -> e:exp -> ct:com -> cf:com -> l:label -> h0:heap -> Lemma (requires ((ni_exp env e l) /\ (ni_com env ct l) /\ (ni_com env cf l))) (ensures (inv_com' env (If e ct cf) l h0)) let cond_inv_com' env e ct cf l h0 = let v = reify (interpret_exp_st e) h0 in if v = 0 then assert (inv_com' env cf l h0 ==> inv_com' env (If e ct cf) l h0) else assert (inv_com' env ct l h0 ==> inv_com' env (If e ct cf) l h0) (* Works too but takes 20s more *) (* let c = if v = 0 then cf else ct in *) (* match reify (interpret_com_st c h0) h0 with *) (* | None, _ -> () *) (* | Some (), h1 -> () *) #reset-options "--max_fuel 1" let interpret_cond (e:exp) (ct:com) (cf:com) (h:heap) : Lemma (let v = reify (interpret_exp_st e) h in let c = if v = 0 then cf else ct in (reify (interpret_com_st (If e ct cf) h) h == reify (interpret_com_st c h) h)) = () val cond_ni_com' : env:label_fun -> e:exp -> ct:com -> cf:com -> l:label -> h0:rel heap -> Lemma (requires ((ni_exp env e l) /\ (ni_com env ct l) /\ (ni_com env cf l))) (ensures (ni_com' env (If e ct cf) l h0)) let cond_ni_com' env e ct cf l h0 = if not (FStar.StrongExcludedMiddle.strong_excluded_middle (low_equiv env h0)) then () else let R h0l h0r = h0 in let vl = reify (interpret_exp_st e) h0l in let vr = reify (interpret_exp_st e) h0r in if Low? l then begin assert (vl == vr) ; let c = if vl = 0 then cf else ct in assert (ni_com env c l) ; let cif = If e ct cf in //NS:05/15 ... this 2 should be trivial to prove. // Why do they require a lemma? interpret_cond e ct cf h0l; interpret_cond e ct cf h0r; use_ni_com env c l (R h0l h0r) end else (* h0 and h1 are low_equiv since cl and cr cannot write at low cells *) match reify (interpret_com_st (If e ct cf) h0l) h0l with | None, _ -> () | Some (), h1l -> match reify (interpret_com_st (If e ct cf) h0r) h0r with | None, _ -> () | Some (), h1r -> cond_inv_com' env e ct cf l h0l ; cond_inv_com' env e ct cf l h0r ; assert (low_equiv env h0 ==> low_equiv env (R h1l h1r)) #set-options "--z3rlimit 5" val cond_com : env:label_fun -> e:exp -> ct:com -> cf:com -> l:label -> Lemma (requires ((ni_exp env e l) /\ (ni_com env ct l) /\ (ni_com env cf l))) (ensures (ni_com env (If e ct cf) l)) let cond_com env e ct cf l = forall_intro (fun (h0:rel heap) -> cond_ni_com' env e ct cf l h0 <: Lemma (ni_com' env (If e ct cf) l h0)) ; forall_intro (fun (h0:heap) -> cond_inv_com' env e ct cf l h0 <: Lemma (inv_com' env (If e ct cf) l h0)) (* Typing rule for Skip ------------------- env,pc:High |- skip *) val skip_com : env:label_fun -> Lemma (ni_com env Skip High) let skip_com _ = () (* While rule for commands env |- e : l env,pc:l |- c ----------------------------------- env,pc:l |- while (e <> 0) do c *) val while_inv_com' : env:label_fun -> e:exp -> c:com -> v:metric -> l:label -> h0:heap -> Lemma (requires (ni_exp env e l /\ ni_com env c l)) (ensures (inv_com' env (While e c v) l h0)) (decreases (decr_while h0 (While e c v))) #reset-options "--z3rlimit 40" let interpret_while_nil e c v h : Lemma (requires (reify (interpret_exp_st e) h <> 0 /\ fst (reify (interpret_com_st c h) h) == None)) (ensures (interpret_com h (While e c v) == None)) = () let interpret_while_loops (e:exp) (c:com) (v:metric) (h:heap) : Lemma (requires (reify (interpret_exp_st e) h <> 0 /\ (match reify (interpret_com_st c h) h with | None, _ -> True | Some _, h' -> interpret_exp' h' v >= interpret_exp' h v))) (ensures (interpret_com h (While e c v) == None)) = () let rec while_inv_com' env e c v l h0 = let v0 = reify (interpret_exp_st e) h0 in if v0 = 0 then assert (interpret_com h0 (While e c v) == Some h0) else let m0 = interpret_exp' h0 v in match reify (interpret_com_st c h0) h0 with | None, _ -> interpret_while_nil e c v h0 | Some (), h2 -> let m1 = interpret_exp' h2 v in if m0 > m1 then begin assert (decr_while h2 (While e c v) << decr_while h0 (While e c v)) ; while_inv_com' env e c v l h2 end else interpret_while_loops e c v h0 val while_ni_com'_low_equiv_high : env:label_fun -> e:exp -> c:com -> v:metric -> l:label -> h0:rel heap -> Lemma (requires (ni_exp env e l /\ ni_com env c l /\ low_equiv env h0 /\ High? l)) (ensures (ni_com' env (While e c v) l h0)) let while_ni_com'_low_equiv_high env e c v l h0 = (* h0 and h1 are low_equiv since cl and cr cannot write at low cells *) let R h0l h0r = h0 in match reify (interpret_com_st (While e c v) h0l) h0l with | None, _ -> () | Some (), h1l -> match reify (interpret_com_st (While e c v) h0r) h0r with | None, _ -> () | Some (), h1r -> while_inv_com' env e c v l h0l ; while_inv_com' env e c v l h0r ; assert (low_equiv env h0 ==> low_equiv env (R h1l h1r)) val while_ni_com'_low_equiv_low : env:label_fun -> e:exp -> c:com -> v:metric -> l:label -> h0:rel heap -> Lemma (requires (ni_exp env e l /\ ni_com env c l /\ low_equiv env h0 /\ Low? l)) (ensures (ni_com' env (While e c v) l h0)) (decreases (decr_while (R?.l h0) (While e c v) + decr_while (R?.r h0) (While e c v))) let rec while_ni_com'_low_equiv_low env e c v l h0 = let R h0l h0r = h0 in let v0l = reify (interpret_exp_st e) h0l in let v0r = reify (interpret_exp_st e) h0r in assert (v0l == v0r) ; if v0l = 0 then begin assert (interpret_com h0l (While e c v) == Some h0l); assert (interpret_com h0r (While e c v) == Some h0r) end else let m0l = interpret_exp' h0l v in let m0r = interpret_exp' h0r v in match reify (interpret_com_st c h0l) h0l with | None, _ -> interpret_while_nil e c v h0l | Some (), h2l -> match reify (interpret_com_st c h0r) h0r with | None, _ -> interpret_while_nil e c v h0r | Some (), h2r -> let m1l = interpret_exp' h2l v in let m1r = interpret_exp' h2r v in if m0l > m1l then if m0r > m1r then begin assert (decr_while h2l (While e c v) << decr_while h0l (While e c v)) ; while_ni_com'_low_equiv_low env e c v l (R h2l h2r) end else interpret_while_loops e c v h0r else interpret_while_loops e c v h0l val while_ni_com' : env:label_fun -> e:exp -> c:com -> v:metric -> l:label -> h0:rel heap -> Lemma (requires (ni_exp env e l /\ ni_com env c l)) (ensures (ni_com' env (While e c v) l h0))

env: IfcRulesReify.label_fun -> e: WhileReify.exp -> c: WhileReify.com -> v: WhileReify.metric -> l: IfcRulesReify.label -> h0: Rel.rel FStar.DM4F.Heap.IntStoreFixed.heap -> FStar.Pervasives.Lemma (requires IfcRulesReify.ni_exp env e l /\ IfcRulesReify.ni_com env c l) (ensures IfcRulesReify.ni_com' env (WhileReify.While e c v) l h0)

FStar.Pervasives.Lemma

let while_ni_com' env e c v l h0 =

if not (FStar.StrongExcludedMiddle.strong_excluded_middle (low_equiv env h0)) then () else if Low? l then while_ni_com'_low_equiv_low env e c v l h0 else while_ni_com'_low_equiv_high env e c v l h0

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.and_elim'

val and_elim' (h: binding) : Tac unit

val and_elim' (h: binding) : Tac unit

let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in ()

h: FStar.Tactics.NamedView.binding -> FStar.Tactics.Effect.Tac Prims.unit

FStar.Tactics.Effect.Tac

let and_elim' (h: binding) : Tac unit =

and_elim (pack (Tv_Var h)); clear h

IfcRulesReify.fst

IfcRulesReify.while_ni_com'_low_equiv_high

val while_ni_com'_low_equiv_high : env:label_fun -> e:exp -> c:com -> v:metric -> l:label -> h0:rel heap -> Lemma (requires (ni_exp env e l /\ ni_com env c l /\ low_equiv env h0 /\ High? l)) (ensures (ni_com' env (While e c v) l h0))

val while_ni_com'_low_equiv_high : env:label_fun -> e:exp -> c:com -> v:metric -> l:label -> h0:rel heap -> Lemma (requires (ni_exp env e l /\ ni_com env c l /\ low_equiv env h0 /\ High? l)) (ensures (ni_com' env (While e c v) l h0))

let while_ni_com'_low_equiv_high env e c v l h0 = (* h0 and h1 are low_equiv since cl and cr cannot write at low cells *) let R h0l h0r = h0 in match reify (interpret_com_st (While e c v) h0l) h0l with | None, _ -> () | Some (), h1l -> match reify (interpret_com_st (While e c v) h0r) h0r with | None, _ -> () | Some (), h1r -> while_inv_com' env e c v l h0l ; while_inv_com' env e c v l h0r ; assert (low_equiv env h0 ==> low_equiv env (R h1l h1r))

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module IfcRulesReify open Rel open WhileReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreExcFixed open FStar.Squash open FStar.Classical (****************************** Preliminaries ******************************) (* CH: Everything specialized to 2-point lattice *) type label = | Low | High val op_Less : label -> label -> Tot bool let op_Less l1 l2 = match l1, l2 with | Low,High -> true | _, _ -> false val op_Less_Equals : label -> label -> Tot bool let op_Less_Equals l1 l2 = match l1, l2 with | High,Low -> false | _, _ -> true val join : label -> label -> Tot label let join l1 l2 = match l1, l2 with | Low,Low -> Low | _, _ -> High val meet : label -> label -> Tot label let meet l1 l2 = match l1, l2 with | High, High -> High | _, _ -> Low let universal_property_meet l l1 l2 : Lemma (requires (l <= l1 /\ l <= l2)) (ensures (l <= meet l1 l2)) = () type label_fun = id -> Tot label type low_equiv (env:label_fun) (h1:rel heap) = (forall (x:id). (* {:pattern (env x)} *) env x = Low ==> index (R?.l h1) x = index (R?.r h1) x) (**************************** Typing Judgements ****************************) (* env |- e : l - Expressions do not modify the heap - Correctness - Low equivalent input heaps + Low label ==> same result *) let ni_exp (env:label_fun) (e:exp) (l:label) : Tot Type0 = forall (h: rel heap). (* {:pattern (low_equiv env h)} *) (low_equiv env h /\ Low? l) ==> (* interpret_exp (R?.r h) e = interpret_exp (R?.l h) e *) begin let vr = reify (interpret_exp_st e) (R?.r h)in let vl = reify (interpret_exp_st e) (R?.l h) in vr = vl end (* env,pc:l |- c - References with a label below l are not modified - Total correctness - Low equivalent input heaps ==> Low equivalent output heaps *) let inv_com' (env:label_fun) (c:com) (l:label) (h0:heap) : Tot Type0 = match interpret_com h0 c with | None -> True | Some h1 -> forall (i:id). (* {:pattern (env i < l)} *) env i < l ==> index h0 i = index h1 i let ni_com' (env:label_fun) (c:com) (l:label) (h0:rel heap) : Tot Type0 = let R h0l h0r = h0 in (* KM : That's the code that we would like to write but subtyping and matching on pairs interplay badly *) (* it generates a VC which boils down to [forall (h1l:heap). length h1l = length h0l] which is obviously false *) (* begin match interpret_com h0l c, interpret_com h0r c with *) (* | Some h1l, Some h1r -> low_equiv env (R h0l h0r) ==> low_equiv env (R h1l h1r) *) (* | _ -> True *) (* end *) begin match interpret_com h0l c with | Some h1l -> begin match interpret_com h0r c with | Some h1r -> low_equiv env h0 ==> low_equiv env (R h1l h1r) | _ -> True end | _ -> True end let ni_com (env:label_fun) (c:com) (l:label) : Tot Type0 = (forall (h0: rel heap). (* {:pattern (low_equiv env h0)} *) ni_com' env c l h0) /\ (forall (h0:heap). (* {:pattern (Some? (interpret_com h0 c))} *) inv_com' env c l h0) (*********************** Typing Rules for Expressions **********************) (* CH: The way we derive these rules looks more like a semantically-justified program logic than a syntactic type system. Any connection to Dave Naumann and Anindya Banerjee's "relational logic"? (e.g. https://arxiv.org/abs/1611.08992) *) (* Subtyping rule for expression labels E |- e : l1 l1 <= l2 ---------------------- E |- e : l2 *) val sub_exp : env:label_fun -> e:exp -> l1:label -> l2:label -> Lemma (requires (l1 <= l2 /\ ni_exp env e l1)) (ensures (ni_exp env e l2)) let sub_exp _ _ _ _ = () (* Typing rule for dereferencing ---------------- E | - r : E(r) *) val avar_exp : env:label_fun -> r:id -> Lemma (ensures (ni_exp env (AVar r) (env r))) let avar_exp _ _ = () (* Typing rule for Int constants i : int ------- i : Low *) val aint_exp : env:label_fun -> i:int -> Lemma (requires True) (ensures (ni_exp env (AInt i) Low)) let aint_exp _ _ = () (* Typing rule for binary operators e1 : l e2 : l ---------------- e1 `op` e2 : l *) val binop_exp : env:label_fun -> op:binop -> e1:exp -> e2:exp -> l:label -> Lemma (requires (ni_exp env e1 l) /\ (ni_exp env e2 l)) (ensures (ni_exp env (AOp op e1 e2) l)) let binop_exp env op e1 e2 l = () (************************ Typing Rules for Commands ************************) (* Subtyping rule for commands env,pc:l1 |- c l2 <= l1 --------------------------- env,pc:l2 |- c *) val sub_com : env:label_fun -> c:com -> l1:label -> l2:label -> Lemma (requires (l2 <= l1 /\ ni_com env c l1 )) (ensures (ni_com env c l2 )) let sub_com _ _ _ _ = () (* Typing rule for assignment env |- e : env(r) ------------------------ env, pc:env(r) |- r := e - label of expression and context label have to be below label of r (first one to prevent explicit, second to prevent implicit flows) *) let assign_inv_com0 (env:label_fun) (e:exp) (r:id) (ne:squash(ni_exp env e (env r))) (h0:rel heap) : Lemma (ni_com' env (Assign r e) (env r) h0) = FStar.Squash.give_proof ne ; let vr = reify (interpret_exp_st e) (R?.r h0) in let vl = reify (interpret_exp_st e) (R?.l h0) in match reify (interpret_com_st (Assign r e) (R?.l h0)) (R?.l h0) with | Some (), h1l -> begin match reify (interpret_com_st (Assign r e) (R?.r h0)) (R?.r h0) with | Some (), h1r -> assert (h1l = upd (R?.l h0) r vl /\ h1r = upd (R?.r h0) r vr) | None, _ -> () end | None, _ -> () let assign_inv_com' (env:label_fun) (e:exp) (r:id) (h0:heap) : Lemma (inv_com' env (Assign r e) (env r) h0) = let v = reify (interpret_exp_st e) h0 in match reify (interpret_com_st (Assign r e) h0) h0 with | None, h1 -> () | Some (), h1 -> assert (h1 == upd h0 r v) val assign_com : env:label_fun -> e:exp -> r:id -> Lemma (requires (ni_exp env e (env r))) (ensures (ni_com env (Assign r e) (env r))) let assign_com env e r = forall_intro (assign_inv_com0 env e r (FStar.Squash.get_proof (ni_exp env e (env r)))) ; forall_intro (assign_inv_com' env e r) let seq_nil1 (c1:com) (c2:com) (h:heap) : Lemma (requires (fst (reify (interpret_com_st c1 h) h) = None)) (ensures (fst (reify (interpret_com_st (Seq c1 c2) h) h) = None)) = () let seq_nil2 (c1:com) (c2:com) (h0:heap) (h1:heap) : Lemma (requires (h1 == snd (reify (interpret_com_st c1 h0) h0) /\ fst (reify (interpret_com_st c2 h1) h1) = None)) (ensures (fst (reify (interpret_com_st (Seq c1 c2) h0) h0) = None)) = () (* Sequencing rule for commands env,pc:l |- c1 env,pc:l |- c2 ------------------------------ env,pc:l |- c1; c2 *) val seq_inv_com' : env:label_fun -> c1:com -> c2:com -> l:label -> h0:heap -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (inv_com' env (Seq c1 c2) l h0)) let seq_inv_com' env c1 c2 l h0 = match reify (interpret_com_st c1 h0) h0 with | None, _ -> seq_nil1 c1 c2 h0 | Some (), h1 -> match reify (interpret_com_st c2 h1) h1 with | None, _ -> seq_nil2 c1 c2 h0 h1 | Some (), h2 -> () #set-options "--z3rlimit 50" let use_ni_com (env:label_fun) (c:com) (l:label) (h:rel heap{low_equiv env h}) : Lemma (requires ni_com env c l) (ensures (let R hl hr = h in match reify (interpret_com_st c hl) hl, reify (interpret_com_st c hr) hr with | (Some _, hl'), (Some _, hr') -> low_equiv env (R hl' hr') | _ -> True)) = () val seq_com' : env:label_fun -> c1:com -> c2:com -> l:label -> h0: rel heap -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (ni_com' env (Seq c1 c2) l h0)) let seq_com' env c1 c2 l h0 = if not (FStar.StrongExcludedMiddle.strong_excluded_middle (low_equiv env h0)) then () else begin assert (low_equiv env h0); let R h0l h0r = h0 in match reify (interpret_com_st c1 h0l) h0l with | None, _ -> seq_nil1 c1 c2 h0l | Some (), h1l -> match reify (interpret_com_st c1 h0r) h0r with | None, _ -> seq_nil1 c1 c2 h0r | Some (), h1r -> match reify (interpret_com_st c2 h1l) h1l with | None, _ -> seq_nil2 c1 c2 h0l h1l | Some (), h2l -> match reify (interpret_com_st c2 h1r) h1r with | None, _ -> seq_nil2 c1 c2 h0r h1r | Some (), h2r -> let h1 = R h1l h1r in use_ni_com env c1 l h0; assert (low_equiv env h1) ; let h2 = R h2l h2r in use_ni_com env c2 l h1; assert (low_equiv env h2) end val seq_com : env:label_fun -> c1:com -> c2:com -> l:label -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (ni_com env (Seq c1 c2) l)) let seq_com env c1 c2 l = forall_intro (fun (h0:rel heap) -> seq_com' env c1 c2 l h0 <: Lemma (ni_com' env (Seq c1 c2) l h0)) ; forall_intro (fun (h0:heap) -> seq_inv_com' env c1 c2 l h0 <: Lemma (inv_com' env (Seq c1 c2) l h0)) (* Typing rule for conditional commands env |- e : l env,pc:l |- ct env,pc:l |- cf ---------------------------------------------- env,pc:l |- if e <> 0 then ct else cf *) (* let project_inv_com' (env:label_fun) (c:com) (l:label) (h0:heap) : Lemma (requires (ni_com env c l)) (ensures (inv_com' env c l h0)) = () *) val cond_inv_com' : env:label_fun -> e:exp -> ct:com -> cf:com -> l:label -> h0:heap -> Lemma (requires ((ni_exp env e l) /\ (ni_com env ct l) /\ (ni_com env cf l))) (ensures (inv_com' env (If e ct cf) l h0)) let cond_inv_com' env e ct cf l h0 = let v = reify (interpret_exp_st e) h0 in if v = 0 then assert (inv_com' env cf l h0 ==> inv_com' env (If e ct cf) l h0) else assert (inv_com' env ct l h0 ==> inv_com' env (If e ct cf) l h0) (* Works too but takes 20s more *) (* let c = if v = 0 then cf else ct in *) (* match reify (interpret_com_st c h0) h0 with *) (* | None, _ -> () *) (* | Some (), h1 -> () *) #reset-options "--max_fuel 1" let interpret_cond (e:exp) (ct:com) (cf:com) (h:heap) : Lemma (let v = reify (interpret_exp_st e) h in let c = if v = 0 then cf else ct in (reify (interpret_com_st (If e ct cf) h) h == reify (interpret_com_st c h) h)) = () val cond_ni_com' : env:label_fun -> e:exp -> ct:com -> cf:com -> l:label -> h0:rel heap -> Lemma (requires ((ni_exp env e l) /\ (ni_com env ct l) /\ (ni_com env cf l))) (ensures (ni_com' env (If e ct cf) l h0)) let cond_ni_com' env e ct cf l h0 = if not (FStar.StrongExcludedMiddle.strong_excluded_middle (low_equiv env h0)) then () else let R h0l h0r = h0 in let vl = reify (interpret_exp_st e) h0l in let vr = reify (interpret_exp_st e) h0r in if Low? l then begin assert (vl == vr) ; let c = if vl = 0 then cf else ct in assert (ni_com env c l) ; let cif = If e ct cf in //NS:05/15 ... this 2 should be trivial to prove. // Why do they require a lemma? interpret_cond e ct cf h0l; interpret_cond e ct cf h0r; use_ni_com env c l (R h0l h0r) end else (* h0 and h1 are low_equiv since cl and cr cannot write at low cells *) match reify (interpret_com_st (If e ct cf) h0l) h0l with | None, _ -> () | Some (), h1l -> match reify (interpret_com_st (If e ct cf) h0r) h0r with | None, _ -> () | Some (), h1r -> cond_inv_com' env e ct cf l h0l ; cond_inv_com' env e ct cf l h0r ; assert (low_equiv env h0 ==> low_equiv env (R h1l h1r)) #set-options "--z3rlimit 5" val cond_com : env:label_fun -> e:exp -> ct:com -> cf:com -> l:label -> Lemma (requires ((ni_exp env e l) /\ (ni_com env ct l) /\ (ni_com env cf l))) (ensures (ni_com env (If e ct cf) l)) let cond_com env e ct cf l = forall_intro (fun (h0:rel heap) -> cond_ni_com' env e ct cf l h0 <: Lemma (ni_com' env (If e ct cf) l h0)) ; forall_intro (fun (h0:heap) -> cond_inv_com' env e ct cf l h0 <: Lemma (inv_com' env (If e ct cf) l h0)) (* Typing rule for Skip ------------------- env,pc:High |- skip *) val skip_com : env:label_fun -> Lemma (ni_com env Skip High) let skip_com _ = () (* While rule for commands env |- e : l env,pc:l |- c ----------------------------------- env,pc:l |- while (e <> 0) do c *) val while_inv_com' : env:label_fun -> e:exp -> c:com -> v:metric -> l:label -> h0:heap -> Lemma (requires (ni_exp env e l /\ ni_com env c l)) (ensures (inv_com' env (While e c v) l h0)) (decreases (decr_while h0 (While e c v))) #reset-options "--z3rlimit 40" let interpret_while_nil e c v h : Lemma (requires (reify (interpret_exp_st e) h <> 0 /\ fst (reify (interpret_com_st c h) h) == None)) (ensures (interpret_com h (While e c v) == None)) = () let interpret_while_loops (e:exp) (c:com) (v:metric) (h:heap) : Lemma (requires (reify (interpret_exp_st e) h <> 0 /\ (match reify (interpret_com_st c h) h with | None, _ -> True | Some _, h' -> interpret_exp' h' v >= interpret_exp' h v))) (ensures (interpret_com h (While e c v) == None)) = () let rec while_inv_com' env e c v l h0 = let v0 = reify (interpret_exp_st e) h0 in if v0 = 0 then assert (interpret_com h0 (While e c v) == Some h0) else let m0 = interpret_exp' h0 v in match reify (interpret_com_st c h0) h0 with | None, _ -> interpret_while_nil e c v h0 | Some (), h2 -> let m1 = interpret_exp' h2 v in if m0 > m1 then begin assert (decr_while h2 (While e c v) << decr_while h0 (While e c v)) ; while_inv_com' env e c v l h2 end else interpret_while_loops e c v h0 val while_ni_com'_low_equiv_high : env:label_fun -> e:exp -> c:com -> v:metric -> l:label -> h0:rel heap -> Lemma (requires (ni_exp env e l /\ ni_com env c l /\ low_equiv env h0 /\ High? l))

env: IfcRulesReify.label_fun -> e: WhileReify.exp -> c: WhileReify.com -> v: WhileReify.metric -> l: IfcRulesReify.label -> h0: Rel.rel FStar.DM4F.Heap.IntStoreFixed.heap -> FStar.Pervasives.Lemma (requires IfcRulesReify.ni_exp env e l /\ IfcRulesReify.ni_com env c l /\ IfcRulesReify.low_equiv env h0 /\ High? l) (ensures IfcRulesReify.ni_com' env (WhileReify.While e c v) l h0)

FStar.Pervasives.Lemma

let while_ni_com'_low_equiv_high env e c v l h0 =

let R h0l h0r = h0 in match reify (interpret_com_st (While e c v) h0l) h0l with | None, _ -> () | Some (), h1l -> match reify (interpret_com_st (While e c v) h0r) h0r with | None, _ -> () | Some (), h1r -> while_inv_com' env e c v l h0l; while_inv_com' env e c v l h0r; assert (low_equiv env h0 ==> low_equiv env (R h1l h1r))

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.repeat'

val repeat' (#a: _) (f: (unit -> Tac a)) : Tac unit

val repeat' (#a: _) (f: (unit -> Tac a)) : Tac unit

let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in ()

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in ()

f: (_: Prims.unit -> FStar.Tactics.Effect.Tac a) -> FStar.Tactics.Effect.Tac Prims.unit

FStar.Tactics.Effect.Tac

let repeat' #a (f: (unit -> Tac a)) : Tac unit =

let _ = repeat f in ()

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.implies_intro'

val implies_intro': Prims.unit -> Tac unit

val implies_intro': Prims.unit -> Tac unit

let implies_intro' () : Tac unit = let _ = implies_intro () in ()

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect.

_: Prims.unit -> FStar.Tactics.Effect.Tac Prims.unit

FStar.Tactics.Effect.Tac

let implies_intro' () : Tac unit =

let _ = implies_intro () in ()

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.exact_hyp'

val exact_hyp' (h: namedv) : Tac unit

val exact_hyp' (h: namedv) : Tac unit

let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h))

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)])

h: FStar.Tactics.NamedView.namedv -> FStar.Tactics.Effect.Tac Prims.unit

FStar.Tactics.Effect.Tac

let exact_hyp' (h: namedv) : Tac unit =

exact (pack (Tv_Var h))

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.return

val return (#a: _) (x: a) : match_res a

val return (#a: _) (x: a) : match_res a

let return #a (x: a) : match_res a = Success x

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp" let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)" /// The exception monad /// ------------------- noeq type match_res a = | Success of a | Failure of match_exception

x: a -> FStar.Tactics.PatternMatching.match_res a

Prims.Tot

let return #a (x: a) : match_res a =

Success x

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.exact_hyp

val exact_hyp (a: Type0) (h: namedv) : Tac unit

val exact_hyp (a: Type0) (h: namedv) : Tac unit

let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)])

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h

a: Type0 -> h: FStar.Tactics.NamedView.namedv -> FStar.Tactics.Effect.Tac Prims.unit

FStar.Tactics.Effect.Tac

let exact_hyp (a: Type0) (h: namedv) : Tac unit =

let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)])

Hacl.Spec.SHA2.Lemmas.fst

Hacl.Spec.SHA2.Lemmas.transpose_state8_lemma

val transpose_state8_lemma: #a:sha2_alg -> #m:m_spec{lanes a m == 8} -> st:state_spec a m -> j:nat{j < lanes a m} -> i:nat{i < 8 * word_length a} -> Lemma (let l = lanes a m in let ind = 8 * j + i / word_length a in Seq.index (vec_v (transpose_state8 st).[ind / l]) (ind % l) == Seq.index (state_spec_v st).[j] (i / word_length a))

val transpose_state8_lemma: #a:sha2_alg -> #m:m_spec{lanes a m == 8} -> st:state_spec a m -> j:nat{j < lanes a m} -> i:nat{i < 8 * word_length a} -> Lemma (let l = lanes a m in let ind = 8 * j + i / word_length a in Seq.index (vec_v (transpose_state8 st).[ind / l]) (ind % l) == Seq.index (state_spec_v st).[j] (i / word_length a))

let transpose_state8_lemma #a #m st j i = let l = lanes a m in let ind = 8 * j + i / word_length a in let r0 = transpose8x8_lseq st in transpose8x8_lemma st

module Hacl.Spec.SHA2.Lemmas open FStar.Mul open Lib.IntTypes open Lib.Sequence open Lib.IntVector open Lib.IntVector.Transpose open Spec.Hash.Definitions open Hacl.Spec.SHA2.Vec #set-options "--z3rlimit 50 --fuel 0 --ifuel 1" val transpose_ws4_lemma_ij: #a:sha2_alg -> #m:m_spec{lanes a m == 4} // lanes a m * lanes a m = 16 -> ws:ws_spec a m -> j:nat{j < lanes a m} -> i:nat{i < 16} -> Lemma (let l = lanes a m in (vec_v (transpose_ws4 ws).[i]).[j] == (vec_v ws.[i / l * l + j]).[i % l]) let transpose_ws4_lemma_ij #a #m ws j i = let l = lanes a m in let i_sub = i / l in let j_sub = i % l in assert (i_sub * l + j_sub == i); let vs = sub ws (i_sub * l) l in eq_intro (sub (transpose_ws4 ws) (i_sub * l) l) (transpose4x4_lseq vs); //assert ((transpose_ws4 ws).[i] == (sub (transpose_ws4 ws) (i_sub * l) l).[j_sub]); //assert ((transpose_ws4 ws).[i] == (transpose4x4_lseq vs).[j_sub]); assert ((vec_v (transpose_ws4 ws).[i]).[j] == (vec_v (transpose4x4_lseq vs).[j_sub]).[j]); transpose4x4_lemma vs; assert ((vec_v (transpose_ws4 ws).[i]).[j] == (vec_v vs.[j]).[j_sub]); assert ((vec_v (transpose_ws4 ws).[i]).[j] == (vec_v ws.[i_sub * l + j]).[j_sub]) val transpose_ws8_lemma_ij: #a:sha2_alg -> #m:m_spec{lanes a m == 8} -> ws:ws_spec a m -> j:nat{j < lanes a m} -> i:nat{i < 16} -> Lemma (let l = lanes a m in (vec_v (transpose_ws8 ws).[i]).[j] == (vec_v ws.[i / l * l + j]).[i % l]) let transpose_ws8_lemma_ij #a #m ws j i = let l = lanes a m in let i_sub = i / l in let j_sub = i % l in assert (i_sub * l + j_sub == i); let vs = sub ws (i_sub * l) l in eq_intro (sub (transpose_ws8 ws) (i_sub * l) l) (transpose8x8_lseq vs); assert ((vec_v (transpose_ws8 ws).[i]).[j] == (vec_v (transpose8x8_lseq vs).[j_sub]).[j]); transpose8x8_lemma vs; assert ((vec_v (transpose_ws8 ws).[i]).[j] == (vec_v ws.[i_sub * lanes a m + j]).[j_sub]) val transpose_ws_lemma_ij: #a:sha2_alg -> #m:m_spec{is_supported a m} -> ws:ws_spec a m -> j:nat{j < lanes a m} -> i:nat{i < 16} -> Lemma (let l = lanes a m in ((ws_spec_v (transpose_ws ws)).[j]).[i] == (vec_v ws.[i / l * l + j]).[i % l]) let transpose_ws_lemma_ij #a #m ws j i = assert (((ws_spec_v (transpose_ws ws)).[j]).[i] == (vec_v (transpose_ws ws).[i]).[j]); match lanes a m with | 1 -> () | 4 -> transpose_ws4_lemma_ij #a #m ws j i | 8 -> transpose_ws8_lemma_ij #a #m ws j i val transpose_state4_lemma: #a:sha2_alg -> #m:m_spec{lanes a m == 4} -> st:state_spec a m -> j:nat{j < lanes a m} -> i:nat{i < 8 * word_length a} -> Lemma (let l = lanes a m in let ind = 8 * j + i / word_length a in Seq.index (vec_v (transpose_state st).[ind / l]) (ind % l) == Seq.index (state_spec_v st).[j] (i / word_length a)) let transpose_state4_lemma #a #m st j i = let r0 = transpose4x4_lseq (sub st 0 4) in transpose4x4_lemma (sub st 0 4); let r1 = transpose4x4_lseq (sub st 4 4) in transpose4x4_lemma (sub st 4 4) val transpose_state8_lemma: #a:sha2_alg -> #m:m_spec{lanes a m == 8} -> st:state_spec a m -> j:nat{j < lanes a m} -> i:nat{i < 8 * word_length a} -> Lemma (let l = lanes a m in let ind = 8 * j + i / word_length a in Seq.index (vec_v (transpose_state8 st).[ind / l]) (ind % l) == Seq.index (state_spec_v st).[j] (i / word_length a))

st: Hacl.Spec.SHA2.Vec.state_spec a m -> j: Prims.nat{j < Hacl.Spec.SHA2.Vec.lanes a m} -> i: Prims.nat{i < 8 * Spec.Hash.Definitions.word_length a} -> FStar.Pervasives.Lemma (ensures (let l = Hacl.Spec.SHA2.Vec.lanes a m in let ind = 8 * j + i / Spec.Hash.Definitions.word_length a in FStar.Seq.Base.index (Lib.IntVector.vec_v (Hacl.Spec.SHA2.Vec.transpose_state8 st).[ ind / l ]) (ind % l) == FStar.Seq.Base.index (Hacl.Spec.SHA2.Vec.state_spec_v st).[ j ] (i / Spec.Hash.Definitions.word_length a)))

FStar.Pervasives.Lemma

let transpose_state8_lemma #a #m st j i =

let l = lanes a m in let ind = 8 * j + i / word_length a in let r0 = transpose8x8_lseq st in transpose8x8_lemma st

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.raise

val raise (#a: _) (ex: match_exception) : match_res a

val raise (#a: _) (ex: match_exception) : match_res a

let raise #a (ex: match_exception) : match_res a = Failure ex

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp" let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)" /// The exception monad /// ------------------- noeq type match_res a = | Success of a | Failure of match_exception let return #a (x: a) : match_res a = Success x let (let?) (#a #b: Type) (f: match_res a) (g: a -> Tac (match_res b)) : Tac (match_res b) = match f with | Success aa -> g aa | Failure ex -> Failure ex

ex: FStar.Tactics.PatternMatching.match_exception -> FStar.Tactics.PatternMatching.match_res a

Prims.Tot

let raise #a (ex: match_exception) : match_res a =

Failure ex

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.string_of_bindings

val string_of_bindings : bindings: FStar.Tactics.PatternMatching.bindings -> FStar.Tactics.Effect.Tac Prims.string

let string_of_bindings (bindings: bindings) = String.concat "\n" (map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm)) bindings)

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp" let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)" /// The exception monad /// ------------------- noeq type match_res a = | Success of a | Failure of match_exception let return #a (x: a) : match_res a = Success x let (let?) (#a #b: Type) (f: match_res a) (g: a -> Tac (match_res b)) : Tac (match_res b) = match f with | Success aa -> g aa | Failure ex -> Failure ex let raise #a (ex: match_exception) : match_res a = Failure ex /// Liftings /// -------- /// /// There's a natural lifting from the exception monad into the tactic effect: let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern interpretation /// ====================== /// /// This section implement pattern-matching. This is strictly a one term, one /// pattern implementation — handling cases in which mutliple hypotheses match /// the same pattern is done later.

bindings: FStar.Tactics.PatternMatching.bindings -> FStar.Tactics.Effect.Tac Prims.string

FStar.Tactics.Effect.Tac

let string_of_bindings (bindings: bindings) =

String.concat "\n" (map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm)) bindings)

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.interp_pattern

val interp_pattern: pat: pattern -> term -> Tac (match_res bindings)

val interp_pattern: pat: pattern -> term -> Tac (match_res bindings)

let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) = fun (tm: term) -> let? rev_bindings = interp_pattern_aux pat [] tm in return (List.Tot.Base.rev rev_bindings)

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp" let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)" /// The exception monad /// ------------------- noeq type match_res a = | Success of a | Failure of match_exception let return #a (x: a) : match_res a = Success x let (let?) (#a #b: Type) (f: match_res a) (g: a -> Tac (match_res b)) : Tac (match_res b) = match f with | Success aa -> g aa | Failure ex -> Failure ex let raise #a (ex: match_exception) : match_res a = Failure ex /// Liftings /// -------- /// /// There's a natural lifting from the exception monad into the tactic effect: let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern interpretation /// ====================== /// /// This section implement pattern-matching. This is strictly a one term, one /// pattern implementation — handling cases in which mutliple hypotheses match /// the same pattern is done later. type bindings = list (varname * term) let string_of_bindings (bindings: bindings) = String.concat "\n" (map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm)) bindings) (** Match a pattern against a term. `cur_bindings` is a list of bindings collected while matching previous parts of the pattern. Returns a result in the exception monad. **) let rec interp_pattern_aux (pat: pattern) (cur_bindings: bindings) (tm:term) : Tac (match_res bindings) = let interp_var (v: varname) cur_bindings tm = match List.Tot.Base.assoc v cur_bindings with | Some tm' -> if term_eq tm tm' then return cur_bindings else raise (NonLinearMismatch (v, tm, tm')) | None -> return ((v, tm) :: cur_bindings) in let interp_qn (qn: qn) cur_bindings tm = match inspect tm with | Tv_UInst fv _ | Tv_FVar fv -> if fv_to_string fv = qn then return cur_bindings else raise (NameMismatch (qn, (fv_to_string fv))) | _ -> raise (SimpleMismatch (pat, tm)) in let interp_type cur_bindings tm = match inspect tm with | Tv_Type _ -> return cur_bindings | _ -> raise (SimpleMismatch (pat, tm)) in let interp_app (p_hd p_arg: (p:pattern{p << pat})) cur_bindings tm = match inspect tm with | Tv_App hd (arg, _) -> let? with_hd = interp_pattern_aux p_hd cur_bindings hd in let? with_arg = interp_pattern_aux p_arg with_hd arg in return with_arg | _ -> raise (SimpleMismatch (pat, tm)) in match pat with | PVar var -> interp_var var cur_bindings tm | PQn qn -> interp_qn qn cur_bindings tm | PType -> interp_type cur_bindings tm | PApp p_hd p_arg -> interp_app p_hd p_arg cur_bindings tm (** Match a pattern `pat` against a term.

pat: FStar.Tactics.PatternMatching.pattern -> _: FStar.Tactics.NamedView.term -> FStar.Tactics.Effect.Tac (FStar.Tactics.PatternMatching.match_res FStar.Tactics.PatternMatching.bindings)

FStar.Tactics.Effect.Tac

let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) =

fun (tm: term) -> let? rev_bindings = interp_pattern_aux pat [] tm in return (List.Tot.Base.rev rev_bindings)

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.absvar

val absvar : Type0

let absvar = binding

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp" let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)" /// The exception monad /// ------------------- noeq type match_res a = | Success of a | Failure of match_exception let return #a (x: a) : match_res a = Success x let (let?) (#a #b: Type) (f: match_res a) (g: a -> Tac (match_res b)) : Tac (match_res b) = match f with | Success aa -> g aa | Failure ex -> Failure ex let raise #a (ex: match_exception) : match_res a = Failure ex /// Liftings /// -------- /// /// There's a natural lifting from the exception monad into the tactic effect: let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern interpretation /// ====================== /// /// This section implement pattern-matching. This is strictly a one term, one /// pattern implementation — handling cases in which mutliple hypotheses match /// the same pattern is done later. type bindings = list (varname * term) let string_of_bindings (bindings: bindings) = String.concat "\n" (map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm)) bindings) (** Match a pattern against a term. `cur_bindings` is a list of bindings collected while matching previous parts of the pattern. Returns a result in the exception monad. **) let rec interp_pattern_aux (pat: pattern) (cur_bindings: bindings) (tm:term) : Tac (match_res bindings) = let interp_var (v: varname) cur_bindings tm = match List.Tot.Base.assoc v cur_bindings with | Some tm' -> if term_eq tm tm' then return cur_bindings else raise (NonLinearMismatch (v, tm, tm')) | None -> return ((v, tm) :: cur_bindings) in let interp_qn (qn: qn) cur_bindings tm = match inspect tm with | Tv_UInst fv _ | Tv_FVar fv -> if fv_to_string fv = qn then return cur_bindings else raise (NameMismatch (qn, (fv_to_string fv))) | _ -> raise (SimpleMismatch (pat, tm)) in let interp_type cur_bindings tm = match inspect tm with | Tv_Type _ -> return cur_bindings | _ -> raise (SimpleMismatch (pat, tm)) in let interp_app (p_hd p_arg: (p:pattern{p << pat})) cur_bindings tm = match inspect tm with | Tv_App hd (arg, _) -> let? with_hd = interp_pattern_aux p_hd cur_bindings hd in let? with_arg = interp_pattern_aux p_arg with_hd arg in return with_arg | _ -> raise (SimpleMismatch (pat, tm)) in match pat with | PVar var -> interp_var var cur_bindings tm | PQn qn -> interp_qn qn cur_bindings tm | PType -> interp_type cur_bindings tm | PApp p_hd p_arg -> interp_app p_hd p_arg cur_bindings tm (** Match a pattern `pat` against a term. Returns a result in the exception monad. **) let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) = fun (tm: term) -> let? rev_bindings = interp_pattern_aux pat [] tm in return (List.Tot.Base.rev rev_bindings) (** Match a term `tm` against a pattern `pat`. Raises an exception if the match fails. This is mostly useful for debugging: use ``mgw`` to capture matches. **) let match_term pat (tm : term) : Tac bindings = match interp_pattern pat (norm_term [] tm) with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern-matching problems /// ========================= /// /// Generalizing past single-term single-pattern problems, we obtain the /// following notions of pattern-matching problems and solutions: let debug msg : Tac unit = () // print msg /// Definitions /// -----------

Type0

Prims.Tot

let absvar =

binding

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.string_of_matching_solution

val string_of_matching_solution : ms: FStar.Tactics.PatternMatching.matching_solution -> FStar.Tactics.Effect.Tac Prims.string

let string_of_matching_solution ms = let vars = String.concat "\n " (map (fun (varname, tm) -> varname ^ ": " ^ (term_to_string tm)) ms.ms_vars) in let hyps = String.concat "\n " (map (fun (nm, binding) -> nm ^ ": " ^ (binding_to_string binding)) ms.ms_hyps) in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ " }"

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp" let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)" /// The exception monad /// ------------------- noeq type match_res a = | Success of a | Failure of match_exception let return #a (x: a) : match_res a = Success x let (let?) (#a #b: Type) (f: match_res a) (g: a -> Tac (match_res b)) : Tac (match_res b) = match f with | Success aa -> g aa | Failure ex -> Failure ex let raise #a (ex: match_exception) : match_res a = Failure ex /// Liftings /// -------- /// /// There's a natural lifting from the exception monad into the tactic effect: let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern interpretation /// ====================== /// /// This section implement pattern-matching. This is strictly a one term, one /// pattern implementation — handling cases in which mutliple hypotheses match /// the same pattern is done later. type bindings = list (varname * term) let string_of_bindings (bindings: bindings) = String.concat "\n" (map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm)) bindings) (** Match a pattern against a term. `cur_bindings` is a list of bindings collected while matching previous parts of the pattern. Returns a result in the exception monad. **) let rec interp_pattern_aux (pat: pattern) (cur_bindings: bindings) (tm:term) : Tac (match_res bindings) = let interp_var (v: varname) cur_bindings tm = match List.Tot.Base.assoc v cur_bindings with | Some tm' -> if term_eq tm tm' then return cur_bindings else raise (NonLinearMismatch (v, tm, tm')) | None -> return ((v, tm) :: cur_bindings) in let interp_qn (qn: qn) cur_bindings tm = match inspect tm with | Tv_UInst fv _ | Tv_FVar fv -> if fv_to_string fv = qn then return cur_bindings else raise (NameMismatch (qn, (fv_to_string fv))) | _ -> raise (SimpleMismatch (pat, tm)) in let interp_type cur_bindings tm = match inspect tm with | Tv_Type _ -> return cur_bindings | _ -> raise (SimpleMismatch (pat, tm)) in let interp_app (p_hd p_arg: (p:pattern{p << pat})) cur_bindings tm = match inspect tm with | Tv_App hd (arg, _) -> let? with_hd = interp_pattern_aux p_hd cur_bindings hd in let? with_arg = interp_pattern_aux p_arg with_hd arg in return with_arg | _ -> raise (SimpleMismatch (pat, tm)) in match pat with | PVar var -> interp_var var cur_bindings tm | PQn qn -> interp_qn qn cur_bindings tm | PType -> interp_type cur_bindings tm | PApp p_hd p_arg -> interp_app p_hd p_arg cur_bindings tm (** Match a pattern `pat` against a term. Returns a result in the exception monad. **) let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) = fun (tm: term) -> let? rev_bindings = interp_pattern_aux pat [] tm in return (List.Tot.Base.rev rev_bindings) (** Match a term `tm` against a pattern `pat`. Raises an exception if the match fails. This is mostly useful for debugging: use ``mgw`` to capture matches. **) let match_term pat (tm : term) : Tac bindings = match interp_pattern pat (norm_term [] tm) with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern-matching problems /// ========================= /// /// Generalizing past single-term single-pattern problems, we obtain the /// following notions of pattern-matching problems and solutions: let debug msg : Tac unit = () // print msg /// Definitions /// ----------- let absvar = binding type hypothesis = binding /// A matching problem is composed of holes (``mp_vars``), hypothesis patterns /// (``mp_hyps``), and a goal pattern (``mp_goal``). noeq type matching_problem = { mp_vars: list varname; mp_hyps: list (varname * pattern); mp_goal: option pattern } let string_of_matching_problem mp = let vars = String.concat ", " mp.mp_vars in let hyps = String.concat "\n " (List.Tot.Base.map (fun (nm, pat) -> nm ^ ": " ^ (string_of_pattern pat)) mp.mp_hyps) in let goal = match mp.mp_goal with | None -> "_" | Some pat -> string_of_pattern pat in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ "\n" ^ " goal: " ^ goal ^ " }" /// A solution is composed of terms captured to mach the holes, and binders /// captured to match hypothesis patterns. noeq type matching_solution = { ms_vars: list (varname * term); ms_hyps: list (varname * hypothesis) }

ms: FStar.Tactics.PatternMatching.matching_solution -> FStar.Tactics.Effect.Tac Prims.string

FStar.Tactics.Effect.Tac

let string_of_matching_solution ms =

let vars = String.concat "\n " (map (fun (varname, tm) -> varname ^ ": " ^ (term_to_string tm)) ms.ms_vars) in let hyps = String.concat "\n " (map (fun (nm, binding) -> nm ^ ": " ^ (binding_to_string binding)) ms.ms_hyps) in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ " }"

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.ms_locate_var

val ms_locate_var (a: Type) (solution: matching_solution) (name: varname) : Tac a

val ms_locate_var (a: Type) (solution: matching_solution) (name: varname) : Tac a

let ms_locate_var (a: Type) (solution: matching_solution) (name: varname) : Tac a = unquote #a (assoc_varname_fail name solution.ms_vars)

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp" let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)" /// The exception monad /// ------------------- noeq type match_res a = | Success of a | Failure of match_exception let return #a (x: a) : match_res a = Success x let (let?) (#a #b: Type) (f: match_res a) (g: a -> Tac (match_res b)) : Tac (match_res b) = match f with | Success aa -> g aa | Failure ex -> Failure ex let raise #a (ex: match_exception) : match_res a = Failure ex /// Liftings /// -------- /// /// There's a natural lifting from the exception monad into the tactic effect: let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern interpretation /// ====================== /// /// This section implement pattern-matching. This is strictly a one term, one /// pattern implementation — handling cases in which mutliple hypotheses match /// the same pattern is done later. type bindings = list (varname * term) let string_of_bindings (bindings: bindings) = String.concat "\n" (map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm)) bindings) (** Match a pattern against a term. `cur_bindings` is a list of bindings collected while matching previous parts of the pattern. Returns a result in the exception monad. **) let rec interp_pattern_aux (pat: pattern) (cur_bindings: bindings) (tm:term) : Tac (match_res bindings) = let interp_var (v: varname) cur_bindings tm = match List.Tot.Base.assoc v cur_bindings with | Some tm' -> if term_eq tm tm' then return cur_bindings else raise (NonLinearMismatch (v, tm, tm')) | None -> return ((v, tm) :: cur_bindings) in let interp_qn (qn: qn) cur_bindings tm = match inspect tm with | Tv_UInst fv _ | Tv_FVar fv -> if fv_to_string fv = qn then return cur_bindings else raise (NameMismatch (qn, (fv_to_string fv))) | _ -> raise (SimpleMismatch (pat, tm)) in let interp_type cur_bindings tm = match inspect tm with | Tv_Type _ -> return cur_bindings | _ -> raise (SimpleMismatch (pat, tm)) in let interp_app (p_hd p_arg: (p:pattern{p << pat})) cur_bindings tm = match inspect tm with | Tv_App hd (arg, _) -> let? with_hd = interp_pattern_aux p_hd cur_bindings hd in let? with_arg = interp_pattern_aux p_arg with_hd arg in return with_arg | _ -> raise (SimpleMismatch (pat, tm)) in match pat with | PVar var -> interp_var var cur_bindings tm | PQn qn -> interp_qn qn cur_bindings tm | PType -> interp_type cur_bindings tm | PApp p_hd p_arg -> interp_app p_hd p_arg cur_bindings tm (** Match a pattern `pat` against a term. Returns a result in the exception monad. **) let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) = fun (tm: term) -> let? rev_bindings = interp_pattern_aux pat [] tm in return (List.Tot.Base.rev rev_bindings) (** Match a term `tm` against a pattern `pat`. Raises an exception if the match fails. This is mostly useful for debugging: use ``mgw`` to capture matches. **) let match_term pat (tm : term) : Tac bindings = match interp_pattern pat (norm_term [] tm) with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern-matching problems /// ========================= /// /// Generalizing past single-term single-pattern problems, we obtain the /// following notions of pattern-matching problems and solutions: let debug msg : Tac unit = () // print msg /// Definitions /// ----------- let absvar = binding type hypothesis = binding /// A matching problem is composed of holes (``mp_vars``), hypothesis patterns /// (``mp_hyps``), and a goal pattern (``mp_goal``). noeq type matching_problem = { mp_vars: list varname; mp_hyps: list (varname * pattern); mp_goal: option pattern } let string_of_matching_problem mp = let vars = String.concat ", " mp.mp_vars in let hyps = String.concat "\n " (List.Tot.Base.map (fun (nm, pat) -> nm ^ ": " ^ (string_of_pattern pat)) mp.mp_hyps) in let goal = match mp.mp_goal with | None -> "_" | Some pat -> string_of_pattern pat in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ "\n" ^ " goal: " ^ goal ^ " }" /// A solution is composed of terms captured to mach the holes, and binders /// captured to match hypothesis patterns. noeq type matching_solution = { ms_vars: list (varname * term); ms_hyps: list (varname * hypothesis) } let string_of_matching_solution ms = let vars = String.concat "\n " (map (fun (varname, tm) -> varname ^ ": " ^ (term_to_string tm)) ms.ms_vars) in let hyps = String.concat "\n " (map (fun (nm, binding) -> nm ^ ": " ^ (binding_to_string binding)) ms.ms_hyps) in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ " }" (** Find a varname in an association list; fail if it can't be found. **) let assoc_varname_fail (#b: Type) (key: varname) (ls: list (varname * b)) : Tac b = match List.Tot.Base.assoc key ls with | None -> fail ("Not found: " ^ key) | Some x -> x let ms_locate_hyp (a: Type) (solution: matching_solution) (name: varname) : Tac hypothesis = assoc_varname_fail name solution.ms_hyps

a: Type -> solution: FStar.Tactics.PatternMatching.matching_solution -> name: FStar.Tactics.PatternMatching.varname -> FStar.Tactics.Effect.Tac a

FStar.Tactics.Effect.Tac

let ms_locate_var (a: Type) (solution: matching_solution) (name: varname) : Tac a =

unquote #a (assoc_varname_fail name solution.ms_vars)

IfcRulesReify.fst

IfcRulesReify.while_ni_com'_low_equiv_low

val while_ni_com'_low_equiv_low : env:label_fun -> e:exp -> c:com -> v:metric -> l:label -> h0:rel heap -> Lemma (requires (ni_exp env e l /\ ni_com env c l /\ low_equiv env h0 /\ Low? l)) (ensures (ni_com' env (While e c v) l h0)) (decreases (decr_while (R?.l h0) (While e c v) + decr_while (R?.r h0) (While e c v)))

val while_ni_com'_low_equiv_low : env:label_fun -> e:exp -> c:com -> v:metric -> l:label -> h0:rel heap -> Lemma (requires (ni_exp env e l /\ ni_com env c l /\ low_equiv env h0 /\ Low? l)) (ensures (ni_com' env (While e c v) l h0)) (decreases (decr_while (R?.l h0) (While e c v) + decr_while (R?.r h0) (While e c v)))

let rec while_ni_com'_low_equiv_low env e c v l h0 = let R h0l h0r = h0 in let v0l = reify (interpret_exp_st e) h0l in let v0r = reify (interpret_exp_st e) h0r in assert (v0l == v0r) ; if v0l = 0 then begin assert (interpret_com h0l (While e c v) == Some h0l); assert (interpret_com h0r (While e c v) == Some h0r) end else let m0l = interpret_exp' h0l v in let m0r = interpret_exp' h0r v in match reify (interpret_com_st c h0l) h0l with | None, _ -> interpret_while_nil e c v h0l | Some (), h2l -> match reify (interpret_com_st c h0r) h0r with | None, _ -> interpret_while_nil e c v h0r | Some (), h2r -> let m1l = interpret_exp' h2l v in let m1r = interpret_exp' h2r v in if m0l > m1l then if m0r > m1r then begin assert (decr_while h2l (While e c v) << decr_while h0l (While e c v)) ; while_ni_com'_low_equiv_low env e c v l (R h2l h2r) end else interpret_while_loops e c v h0r else interpret_while_loops e c v h0l

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module IfcRulesReify open Rel open WhileReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreExcFixed open FStar.Squash open FStar.Classical (****************************** Preliminaries ******************************) (* CH: Everything specialized to 2-point lattice *) type label = | Low | High val op_Less : label -> label -> Tot bool let op_Less l1 l2 = match l1, l2 with | Low,High -> true | _, _ -> false val op_Less_Equals : label -> label -> Tot bool let op_Less_Equals l1 l2 = match l1, l2 with | High,Low -> false | _, _ -> true val join : label -> label -> Tot label let join l1 l2 = match l1, l2 with | Low,Low -> Low | _, _ -> High val meet : label -> label -> Tot label let meet l1 l2 = match l1, l2 with | High, High -> High | _, _ -> Low let universal_property_meet l l1 l2 : Lemma (requires (l <= l1 /\ l <= l2)) (ensures (l <= meet l1 l2)) = () type label_fun = id -> Tot label type low_equiv (env:label_fun) (h1:rel heap) = (forall (x:id). (* {:pattern (env x)} *) env x = Low ==> index (R?.l h1) x = index (R?.r h1) x) (**************************** Typing Judgements ****************************) (* env |- e : l - Expressions do not modify the heap - Correctness - Low equivalent input heaps + Low label ==> same result *) let ni_exp (env:label_fun) (e:exp) (l:label) : Tot Type0 = forall (h: rel heap). (* {:pattern (low_equiv env h)} *) (low_equiv env h /\ Low? l) ==> (* interpret_exp (R?.r h) e = interpret_exp (R?.l h) e *) begin let vr = reify (interpret_exp_st e) (R?.r h)in let vl = reify (interpret_exp_st e) (R?.l h) in vr = vl end (* env,pc:l |- c - References with a label below l are not modified - Total correctness - Low equivalent input heaps ==> Low equivalent output heaps *) let inv_com' (env:label_fun) (c:com) (l:label) (h0:heap) : Tot Type0 = match interpret_com h0 c with | None -> True | Some h1 -> forall (i:id). (* {:pattern (env i < l)} *) env i < l ==> index h0 i = index h1 i let ni_com' (env:label_fun) (c:com) (l:label) (h0:rel heap) : Tot Type0 = let R h0l h0r = h0 in (* KM : That's the code that we would like to write but subtyping and matching on pairs interplay badly *) (* it generates a VC which boils down to [forall (h1l:heap). length h1l = length h0l] which is obviously false *) (* begin match interpret_com h0l c, interpret_com h0r c with *) (* | Some h1l, Some h1r -> low_equiv env (R h0l h0r) ==> low_equiv env (R h1l h1r) *) (* | _ -> True *) (* end *) begin match interpret_com h0l c with | Some h1l -> begin match interpret_com h0r c with | Some h1r -> low_equiv env h0 ==> low_equiv env (R h1l h1r) | _ -> True end | _ -> True end let ni_com (env:label_fun) (c:com) (l:label) : Tot Type0 = (forall (h0: rel heap). (* {:pattern (low_equiv env h0)} *) ni_com' env c l h0) /\ (forall (h0:heap). (* {:pattern (Some? (interpret_com h0 c))} *) inv_com' env c l h0) (*********************** Typing Rules for Expressions **********************) (* CH: The way we derive these rules looks more like a semantically-justified program logic than a syntactic type system. Any connection to Dave Naumann and Anindya Banerjee's "relational logic"? (e.g. https://arxiv.org/abs/1611.08992) *) (* Subtyping rule for expression labels E |- e : l1 l1 <= l2 ---------------------- E |- e : l2 *) val sub_exp : env:label_fun -> e:exp -> l1:label -> l2:label -> Lemma (requires (l1 <= l2 /\ ni_exp env e l1)) (ensures (ni_exp env e l2)) let sub_exp _ _ _ _ = () (* Typing rule for dereferencing ---------------- E | - r : E(r) *) val avar_exp : env:label_fun -> r:id -> Lemma (ensures (ni_exp env (AVar r) (env r))) let avar_exp _ _ = () (* Typing rule for Int constants i : int ------- i : Low *) val aint_exp : env:label_fun -> i:int -> Lemma (requires True) (ensures (ni_exp env (AInt i) Low)) let aint_exp _ _ = () (* Typing rule for binary operators e1 : l e2 : l ---------------- e1 `op` e2 : l *) val binop_exp : env:label_fun -> op:binop -> e1:exp -> e2:exp -> l:label -> Lemma (requires (ni_exp env e1 l) /\ (ni_exp env e2 l)) (ensures (ni_exp env (AOp op e1 e2) l)) let binop_exp env op e1 e2 l = () (************************ Typing Rules for Commands ************************) (* Subtyping rule for commands env,pc:l1 |- c l2 <= l1 --------------------------- env,pc:l2 |- c *) val sub_com : env:label_fun -> c:com -> l1:label -> l2:label -> Lemma (requires (l2 <= l1 /\ ni_com env c l1 )) (ensures (ni_com env c l2 )) let sub_com _ _ _ _ = () (* Typing rule for assignment env |- e : env(r) ------------------------ env, pc:env(r) |- r := e - label of expression and context label have to be below label of r (first one to prevent explicit, second to prevent implicit flows) *) let assign_inv_com0 (env:label_fun) (e:exp) (r:id) (ne:squash(ni_exp env e (env r))) (h0:rel heap) : Lemma (ni_com' env (Assign r e) (env r) h0) = FStar.Squash.give_proof ne ; let vr = reify (interpret_exp_st e) (R?.r h0) in let vl = reify (interpret_exp_st e) (R?.l h0) in match reify (interpret_com_st (Assign r e) (R?.l h0)) (R?.l h0) with | Some (), h1l -> begin match reify (interpret_com_st (Assign r e) (R?.r h0)) (R?.r h0) with | Some (), h1r -> assert (h1l = upd (R?.l h0) r vl /\ h1r = upd (R?.r h0) r vr) | None, _ -> () end | None, _ -> () let assign_inv_com' (env:label_fun) (e:exp) (r:id) (h0:heap) : Lemma (inv_com' env (Assign r e) (env r) h0) = let v = reify (interpret_exp_st e) h0 in match reify (interpret_com_st (Assign r e) h0) h0 with | None, h1 -> () | Some (), h1 -> assert (h1 == upd h0 r v) val assign_com : env:label_fun -> e:exp -> r:id -> Lemma (requires (ni_exp env e (env r))) (ensures (ni_com env (Assign r e) (env r))) let assign_com env e r = forall_intro (assign_inv_com0 env e r (FStar.Squash.get_proof (ni_exp env e (env r)))) ; forall_intro (assign_inv_com' env e r) let seq_nil1 (c1:com) (c2:com) (h:heap) : Lemma (requires (fst (reify (interpret_com_st c1 h) h) = None)) (ensures (fst (reify (interpret_com_st (Seq c1 c2) h) h) = None)) = () let seq_nil2 (c1:com) (c2:com) (h0:heap) (h1:heap) : Lemma (requires (h1 == snd (reify (interpret_com_st c1 h0) h0) /\ fst (reify (interpret_com_st c2 h1) h1) = None)) (ensures (fst (reify (interpret_com_st (Seq c1 c2) h0) h0) = None)) = () (* Sequencing rule for commands env,pc:l |- c1 env,pc:l |- c2 ------------------------------ env,pc:l |- c1; c2 *) val seq_inv_com' : env:label_fun -> c1:com -> c2:com -> l:label -> h0:heap -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (inv_com' env (Seq c1 c2) l h0)) let seq_inv_com' env c1 c2 l h0 = match reify (interpret_com_st c1 h0) h0 with | None, _ -> seq_nil1 c1 c2 h0 | Some (), h1 -> match reify (interpret_com_st c2 h1) h1 with | None, _ -> seq_nil2 c1 c2 h0 h1 | Some (), h2 -> () #set-options "--z3rlimit 50" let use_ni_com (env:label_fun) (c:com) (l:label) (h:rel heap{low_equiv env h}) : Lemma (requires ni_com env c l) (ensures (let R hl hr = h in match reify (interpret_com_st c hl) hl, reify (interpret_com_st c hr) hr with | (Some _, hl'), (Some _, hr') -> low_equiv env (R hl' hr') | _ -> True)) = () val seq_com' : env:label_fun -> c1:com -> c2:com -> l:label -> h0: rel heap -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (ni_com' env (Seq c1 c2) l h0)) let seq_com' env c1 c2 l h0 = if not (FStar.StrongExcludedMiddle.strong_excluded_middle (low_equiv env h0)) then () else begin assert (low_equiv env h0); let R h0l h0r = h0 in match reify (interpret_com_st c1 h0l) h0l with | None, _ -> seq_nil1 c1 c2 h0l | Some (), h1l -> match reify (interpret_com_st c1 h0r) h0r with | None, _ -> seq_nil1 c1 c2 h0r | Some (), h1r -> match reify (interpret_com_st c2 h1l) h1l with | None, _ -> seq_nil2 c1 c2 h0l h1l | Some (), h2l -> match reify (interpret_com_st c2 h1r) h1r with | None, _ -> seq_nil2 c1 c2 h0r h1r | Some (), h2r -> let h1 = R h1l h1r in use_ni_com env c1 l h0; assert (low_equiv env h1) ; let h2 = R h2l h2r in use_ni_com env c2 l h1; assert (low_equiv env h2) end val seq_com : env:label_fun -> c1:com -> c2:com -> l:label -> Lemma (requires (ni_com env c1 l /\ ni_com env c2 l)) (ensures (ni_com env (Seq c1 c2) l)) let seq_com env c1 c2 l = forall_intro (fun (h0:rel heap) -> seq_com' env c1 c2 l h0 <: Lemma (ni_com' env (Seq c1 c2) l h0)) ; forall_intro (fun (h0:heap) -> seq_inv_com' env c1 c2 l h0 <: Lemma (inv_com' env (Seq c1 c2) l h0)) (* Typing rule for conditional commands env |- e : l env,pc:l |- ct env,pc:l |- cf ---------------------------------------------- env,pc:l |- if e <> 0 then ct else cf *) (* let project_inv_com' (env:label_fun) (c:com) (l:label) (h0:heap) : Lemma (requires (ni_com env c l)) (ensures (inv_com' env c l h0)) = () *) val cond_inv_com' : env:label_fun -> e:exp -> ct:com -> cf:com -> l:label -> h0:heap -> Lemma (requires ((ni_exp env e l) /\ (ni_com env ct l) /\ (ni_com env cf l))) (ensures (inv_com' env (If e ct cf) l h0)) let cond_inv_com' env e ct cf l h0 = let v = reify (interpret_exp_st e) h0 in if v = 0 then assert (inv_com' env cf l h0 ==> inv_com' env (If e ct cf) l h0) else assert (inv_com' env ct l h0 ==> inv_com' env (If e ct cf) l h0) (* Works too but takes 20s more *) (* let c = if v = 0 then cf else ct in *) (* match reify (interpret_com_st c h0) h0 with *) (* | None, _ -> () *) (* | Some (), h1 -> () *) #reset-options "--max_fuel 1" let interpret_cond (e:exp) (ct:com) (cf:com) (h:heap) : Lemma (let v = reify (interpret_exp_st e) h in let c = if v = 0 then cf else ct in (reify (interpret_com_st (If e ct cf) h) h == reify (interpret_com_st c h) h)) = () val cond_ni_com' : env:label_fun -> e:exp -> ct:com -> cf:com -> l:label -> h0:rel heap -> Lemma (requires ((ni_exp env e l) /\ (ni_com env ct l) /\ (ni_com env cf l))) (ensures (ni_com' env (If e ct cf) l h0)) let cond_ni_com' env e ct cf l h0 = if not (FStar.StrongExcludedMiddle.strong_excluded_middle (low_equiv env h0)) then () else let R h0l h0r = h0 in let vl = reify (interpret_exp_st e) h0l in let vr = reify (interpret_exp_st e) h0r in if Low? l then begin assert (vl == vr) ; let c = if vl = 0 then cf else ct in assert (ni_com env c l) ; let cif = If e ct cf in //NS:05/15 ... this 2 should be trivial to prove. // Why do they require a lemma? interpret_cond e ct cf h0l; interpret_cond e ct cf h0r; use_ni_com env c l (R h0l h0r) end else (* h0 and h1 are low_equiv since cl and cr cannot write at low cells *) match reify (interpret_com_st (If e ct cf) h0l) h0l with | None, _ -> () | Some (), h1l -> match reify (interpret_com_st (If e ct cf) h0r) h0r with | None, _ -> () | Some (), h1r -> cond_inv_com' env e ct cf l h0l ; cond_inv_com' env e ct cf l h0r ; assert (low_equiv env h0 ==> low_equiv env (R h1l h1r)) #set-options "--z3rlimit 5" val cond_com : env:label_fun -> e:exp -> ct:com -> cf:com -> l:label -> Lemma (requires ((ni_exp env e l) /\ (ni_com env ct l) /\ (ni_com env cf l))) (ensures (ni_com env (If e ct cf) l)) let cond_com env e ct cf l = forall_intro (fun (h0:rel heap) -> cond_ni_com' env e ct cf l h0 <: Lemma (ni_com' env (If e ct cf) l h0)) ; forall_intro (fun (h0:heap) -> cond_inv_com' env e ct cf l h0 <: Lemma (inv_com' env (If e ct cf) l h0)) (* Typing rule for Skip ------------------- env,pc:High |- skip *) val skip_com : env:label_fun -> Lemma (ni_com env Skip High) let skip_com _ = () (* While rule for commands env |- e : l env,pc:l |- c ----------------------------------- env,pc:l |- while (e <> 0) do c *) val while_inv_com' : env:label_fun -> e:exp -> c:com -> v:metric -> l:label -> h0:heap -> Lemma (requires (ni_exp env e l /\ ni_com env c l)) (ensures (inv_com' env (While e c v) l h0)) (decreases (decr_while h0 (While e c v))) #reset-options "--z3rlimit 40" let interpret_while_nil e c v h : Lemma (requires (reify (interpret_exp_st e) h <> 0 /\ fst (reify (interpret_com_st c h) h) == None)) (ensures (interpret_com h (While e c v) == None)) = () let interpret_while_loops (e:exp) (c:com) (v:metric) (h:heap) : Lemma (requires (reify (interpret_exp_st e) h <> 0 /\ (match reify (interpret_com_st c h) h with | None, _ -> True | Some _, h' -> interpret_exp' h' v >= interpret_exp' h v))) (ensures (interpret_com h (While e c v) == None)) = () let rec while_inv_com' env e c v l h0 = let v0 = reify (interpret_exp_st e) h0 in if v0 = 0 then assert (interpret_com h0 (While e c v) == Some h0) else let m0 = interpret_exp' h0 v in match reify (interpret_com_st c h0) h0 with | None, _ -> interpret_while_nil e c v h0 | Some (), h2 -> let m1 = interpret_exp' h2 v in if m0 > m1 then begin assert (decr_while h2 (While e c v) << decr_while h0 (While e c v)) ; while_inv_com' env e c v l h2 end else interpret_while_loops e c v h0 val while_ni_com'_low_equiv_high : env:label_fun -> e:exp -> c:com -> v:metric -> l:label -> h0:rel heap -> Lemma (requires (ni_exp env e l /\ ni_com env c l /\ low_equiv env h0 /\ High? l)) (ensures (ni_com' env (While e c v) l h0)) let while_ni_com'_low_equiv_high env e c v l h0 = (* h0 and h1 are low_equiv since cl and cr cannot write at low cells *) let R h0l h0r = h0 in match reify (interpret_com_st (While e c v) h0l) h0l with | None, _ -> () | Some (), h1l -> match reify (interpret_com_st (While e c v) h0r) h0r with | None, _ -> () | Some (), h1r -> while_inv_com' env e c v l h0l ; while_inv_com' env e c v l h0r ; assert (low_equiv env h0 ==> low_equiv env (R h1l h1r)) val while_ni_com'_low_equiv_low : env:label_fun -> e:exp -> c:com -> v:metric -> l:label -> h0:rel heap -> Lemma (requires (ni_exp env e l /\ ni_com env c l /\ low_equiv env h0 /\ Low? l)) (ensures (ni_com' env (While e c v) l h0))

env: IfcRulesReify.label_fun -> e: WhileReify.exp -> c: WhileReify.com -> v: WhileReify.metric -> l: IfcRulesReify.label -> h0: Rel.rel FStar.DM4F.Heap.IntStoreFixed.heap -> FStar.Pervasives.Lemma (requires IfcRulesReify.ni_exp env e l /\ IfcRulesReify.ni_com env c l /\ IfcRulesReify.low_equiv env h0 /\ Low? l) (ensures IfcRulesReify.ni_com' env (WhileReify.While e c v) l h0) (decreases WhileReify.decr_while (R?.l h0) (WhileReify.While e c v) + WhileReify.decr_while (R?.r h0) (WhileReify.While e c v))

FStar.Pervasives.Lemma

let rec while_ni_com'_low_equiv_low env e c v l h0 =

let R h0l h0r = h0 in let v0l = reify (interpret_exp_st e) h0l in let v0r = reify (interpret_exp_st e) h0r in assert (v0l == v0r); if v0l = 0 then (assert (interpret_com h0l (While e c v) == Some h0l); assert (interpret_com h0r (While e c v) == Some h0r)) else let m0l = interpret_exp' h0l v in let m0r = interpret_exp' h0r v in match reify (interpret_com_st c h0l) h0l with | None, _ -> interpret_while_nil e c v h0l | Some (), h2l -> match reify (interpret_com_st c h0r) h0r with | None, _ -> interpret_while_nil e c v h0r | Some (), h2r -> let m1l = interpret_exp' h2l v in let m1r = interpret_exp' h2r v in if m0l > m1l then if m0r > m1r then (assert (decr_while h2l (While e c v) << decr_while h0l (While e c v)); while_ni_com'_low_equiv_low env e c v l (R h2l h2r)) else interpret_while_loops e c v h0r else interpret_while_loops e c v h0l

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.ms_locate_hyp

val ms_locate_hyp (a: Type) (solution: matching_solution) (name: varname) : Tac hypothesis

val ms_locate_hyp (a: Type) (solution: matching_solution) (name: varname) : Tac hypothesis

let ms_locate_hyp (a: Type) (solution: matching_solution) (name: varname) : Tac hypothesis = assoc_varname_fail name solution.ms_hyps

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp" let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)" /// The exception monad /// ------------------- noeq type match_res a = | Success of a | Failure of match_exception let return #a (x: a) : match_res a = Success x let (let?) (#a #b: Type) (f: match_res a) (g: a -> Tac (match_res b)) : Tac (match_res b) = match f with | Success aa -> g aa | Failure ex -> Failure ex let raise #a (ex: match_exception) : match_res a = Failure ex /// Liftings /// -------- /// /// There's a natural lifting from the exception monad into the tactic effect: let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern interpretation /// ====================== /// /// This section implement pattern-matching. This is strictly a one term, one /// pattern implementation — handling cases in which mutliple hypotheses match /// the same pattern is done later. type bindings = list (varname * term) let string_of_bindings (bindings: bindings) = String.concat "\n" (map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm)) bindings) (** Match a pattern against a term. `cur_bindings` is a list of bindings collected while matching previous parts of the pattern. Returns a result in the exception monad. **) let rec interp_pattern_aux (pat: pattern) (cur_bindings: bindings) (tm:term) : Tac (match_res bindings) = let interp_var (v: varname) cur_bindings tm = match List.Tot.Base.assoc v cur_bindings with | Some tm' -> if term_eq tm tm' then return cur_bindings else raise (NonLinearMismatch (v, tm, tm')) | None -> return ((v, tm) :: cur_bindings) in let interp_qn (qn: qn) cur_bindings tm = match inspect tm with | Tv_UInst fv _ | Tv_FVar fv -> if fv_to_string fv = qn then return cur_bindings else raise (NameMismatch (qn, (fv_to_string fv))) | _ -> raise (SimpleMismatch (pat, tm)) in let interp_type cur_bindings tm = match inspect tm with | Tv_Type _ -> return cur_bindings | _ -> raise (SimpleMismatch (pat, tm)) in let interp_app (p_hd p_arg: (p:pattern{p << pat})) cur_bindings tm = match inspect tm with | Tv_App hd (arg, _) -> let? with_hd = interp_pattern_aux p_hd cur_bindings hd in let? with_arg = interp_pattern_aux p_arg with_hd arg in return with_arg | _ -> raise (SimpleMismatch (pat, tm)) in match pat with | PVar var -> interp_var var cur_bindings tm | PQn qn -> interp_qn qn cur_bindings tm | PType -> interp_type cur_bindings tm | PApp p_hd p_arg -> interp_app p_hd p_arg cur_bindings tm (** Match a pattern `pat` against a term. Returns a result in the exception monad. **) let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) = fun (tm: term) -> let? rev_bindings = interp_pattern_aux pat [] tm in return (List.Tot.Base.rev rev_bindings) (** Match a term `tm` against a pattern `pat`. Raises an exception if the match fails. This is mostly useful for debugging: use ``mgw`` to capture matches. **) let match_term pat (tm : term) : Tac bindings = match interp_pattern pat (norm_term [] tm) with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern-matching problems /// ========================= /// /// Generalizing past single-term single-pattern problems, we obtain the /// following notions of pattern-matching problems and solutions: let debug msg : Tac unit = () // print msg /// Definitions /// ----------- let absvar = binding type hypothesis = binding /// A matching problem is composed of holes (``mp_vars``), hypothesis patterns /// (``mp_hyps``), and a goal pattern (``mp_goal``). noeq type matching_problem = { mp_vars: list varname; mp_hyps: list (varname * pattern); mp_goal: option pattern } let string_of_matching_problem mp = let vars = String.concat ", " mp.mp_vars in let hyps = String.concat "\n " (List.Tot.Base.map (fun (nm, pat) -> nm ^ ": " ^ (string_of_pattern pat)) mp.mp_hyps) in let goal = match mp.mp_goal with | None -> "_" | Some pat -> string_of_pattern pat in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ "\n" ^ " goal: " ^ goal ^ " }" /// A solution is composed of terms captured to mach the holes, and binders /// captured to match hypothesis patterns. noeq type matching_solution = { ms_vars: list (varname * term); ms_hyps: list (varname * hypothesis) } let string_of_matching_solution ms = let vars = String.concat "\n " (map (fun (varname, tm) -> varname ^ ": " ^ (term_to_string tm)) ms.ms_vars) in let hyps = String.concat "\n " (map (fun (nm, binding) -> nm ^ ": " ^ (binding_to_string binding)) ms.ms_hyps) in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ " }" (** Find a varname in an association list; fail if it can't be found. **) let assoc_varname_fail (#b: Type) (key: varname) (ls: list (varname * b)) : Tac b = match List.Tot.Base.assoc key ls with | None -> fail ("Not found: " ^ key) | Some x -> x

a: Type -> solution: FStar.Tactics.PatternMatching.matching_solution -> name: FStar.Tactics.PatternMatching.varname -> FStar.Tactics.Effect.Tac FStar.Tactics.PatternMatching.hypothesis

FStar.Tactics.Effect.Tac

let ms_locate_hyp (a: Type) (solution: matching_solution) (name: varname) : Tac hypothesis =

assoc_varname_fail name solution.ms_hyps

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.hyp_qn

val hyp_qn : Prims.string

let hyp_qn = `%hyp

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp" let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)" /// The exception monad /// ------------------- noeq type match_res a = | Success of a | Failure of match_exception let return #a (x: a) : match_res a = Success x let (let?) (#a #b: Type) (f: match_res a) (g: a -> Tac (match_res b)) : Tac (match_res b) = match f with | Success aa -> g aa | Failure ex -> Failure ex let raise #a (ex: match_exception) : match_res a = Failure ex /// Liftings /// -------- /// /// There's a natural lifting from the exception monad into the tactic effect: let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern interpretation /// ====================== /// /// This section implement pattern-matching. This is strictly a one term, one /// pattern implementation — handling cases in which mutliple hypotheses match /// the same pattern is done later. type bindings = list (varname * term) let string_of_bindings (bindings: bindings) = String.concat "\n" (map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm)) bindings) (** Match a pattern against a term. `cur_bindings` is a list of bindings collected while matching previous parts of the pattern. Returns a result in the exception monad. **) let rec interp_pattern_aux (pat: pattern) (cur_bindings: bindings) (tm:term) : Tac (match_res bindings) = let interp_var (v: varname) cur_bindings tm = match List.Tot.Base.assoc v cur_bindings with | Some tm' -> if term_eq tm tm' then return cur_bindings else raise (NonLinearMismatch (v, tm, tm')) | None -> return ((v, tm) :: cur_bindings) in let interp_qn (qn: qn) cur_bindings tm = match inspect tm with | Tv_UInst fv _ | Tv_FVar fv -> if fv_to_string fv = qn then return cur_bindings else raise (NameMismatch (qn, (fv_to_string fv))) | _ -> raise (SimpleMismatch (pat, tm)) in let interp_type cur_bindings tm = match inspect tm with | Tv_Type _ -> return cur_bindings | _ -> raise (SimpleMismatch (pat, tm)) in let interp_app (p_hd p_arg: (p:pattern{p << pat})) cur_bindings tm = match inspect tm with | Tv_App hd (arg, _) -> let? with_hd = interp_pattern_aux p_hd cur_bindings hd in let? with_arg = interp_pattern_aux p_arg with_hd arg in return with_arg | _ -> raise (SimpleMismatch (pat, tm)) in match pat with | PVar var -> interp_var var cur_bindings tm | PQn qn -> interp_qn qn cur_bindings tm | PType -> interp_type cur_bindings tm | PApp p_hd p_arg -> interp_app p_hd p_arg cur_bindings tm (** Match a pattern `pat` against a term. Returns a result in the exception monad. **) let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) = fun (tm: term) -> let? rev_bindings = interp_pattern_aux pat [] tm in return (List.Tot.Base.rev rev_bindings) (** Match a term `tm` against a pattern `pat`. Raises an exception if the match fails. This is mostly useful for debugging: use ``mgw`` to capture matches. **) let match_term pat (tm : term) : Tac bindings = match interp_pattern pat (norm_term [] tm) with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern-matching problems /// ========================= /// /// Generalizing past single-term single-pattern problems, we obtain the /// following notions of pattern-matching problems and solutions: let debug msg : Tac unit = () // print msg /// Definitions /// ----------- let absvar = binding type hypothesis = binding /// A matching problem is composed of holes (``mp_vars``), hypothesis patterns /// (``mp_hyps``), and a goal pattern (``mp_goal``). noeq type matching_problem = { mp_vars: list varname; mp_hyps: list (varname * pattern); mp_goal: option pattern } let string_of_matching_problem mp = let vars = String.concat ", " mp.mp_vars in let hyps = String.concat "\n " (List.Tot.Base.map (fun (nm, pat) -> nm ^ ": " ^ (string_of_pattern pat)) mp.mp_hyps) in let goal = match mp.mp_goal with | None -> "_" | Some pat -> string_of_pattern pat in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ "\n" ^ " goal: " ^ goal ^ " }" /// A solution is composed of terms captured to mach the holes, and binders /// captured to match hypothesis patterns. noeq type matching_solution = { ms_vars: list (varname * term); ms_hyps: list (varname * hypothesis) } let string_of_matching_solution ms = let vars = String.concat "\n " (map (fun (varname, tm) -> varname ^ ": " ^ (term_to_string tm)) ms.ms_vars) in let hyps = String.concat "\n " (map (fun (nm, binding) -> nm ^ ": " ^ (binding_to_string binding)) ms.ms_hyps) in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ " }" (** Find a varname in an association list; fail if it can't be found. **) let assoc_varname_fail (#b: Type) (key: varname) (ls: list (varname * b)) : Tac b = match List.Tot.Base.assoc key ls with | None -> fail ("Not found: " ^ key) | Some x -> x let ms_locate_hyp (a: Type) (solution: matching_solution) (name: varname) : Tac hypothesis = assoc_varname_fail name solution.ms_hyps let ms_locate_var (a: Type) (solution: matching_solution) (name: varname) : Tac a = unquote #a (assoc_varname_fail name solution.ms_vars) let ms_locate_unit (a: Type) _solution _binder_name : Tac unit = () /// Resolution /// ---------- /// /// Solving a matching problem is a two-steps process: find an initial /// assignment for holes based on the goal pattern, then find a set of /// hypotheses matching hypothesis patterns. /// /// Note that the implementation takes a continuation of type /// ``matching_solution -> Tac a``. This continuation is needed because we want /// users to be able to provide extra criteria on matching solutions (most /// commonly, this criterion is that a particular tactic should run /// successfuly). /// /// This makes it easy to implement a simple for of search through the context, /// where one can find a hypothesis matching a particular predicate by /// constructing a trivial matching problem and passing the predicate as the /// continuation. (** Scan ``hypotheses`` for a match for ``pat`` that lets ``body`` succeed. ``name`` is used to refer to the hypothesis matched in the final solution. ``part_sol`` includes bindings gathered while matching previous solutions. **) let rec solve_mp_for_single_hyp #a (name: varname) (pat: pattern) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (part_sol: matching_solution) : Tac a = match hypotheses with | [] -> fail #a "No matching hypothesis" | h :: hs -> or_else // Must be in ``Tac`` here to run `body` (fun () -> match interp_pattern_aux pat part_sol.ms_vars (type_of_binding h) with | Failure ex -> fail ("Failed to match hyp: " ^ (string_of_match_exception ex)) | Success bindings -> let ms_hyps = (name, h) :: part_sol.ms_hyps in body ({ part_sol with ms_vars = bindings; ms_hyps = ms_hyps })) (fun () -> solve_mp_for_single_hyp name pat hs body part_sol) (** Scan ``hypotheses`` for matches for ``mp_hyps`` that lets ``body`` succeed. **) let rec solve_mp_for_hyps #a (mp_hyps: list (varname * pattern)) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (partial_solution: matching_solution) : Tac a = match mp_hyps with | [] -> body partial_solution | (name, pat) :: pats -> solve_mp_for_single_hyp name pat hypotheses (solve_mp_for_hyps pats hypotheses body) partial_solution (** Solve a matching problem. The solution returned is constructed to ensure that the continuation ``body`` succeeds: this implements the usual backtracking-match semantics. **) let solve_mp #a (problem: matching_problem) (hypotheses: list hypothesis) (goal: term) (body: matching_solution -> Tac a) : Tac a = let goal_ps = match problem.mp_goal with | None -> { ms_vars = []; ms_hyps = [] } | Some pat -> match interp_pattern pat goal with | Failure ex -> fail ("Failed to match goal: " ^ (string_of_match_exception ex)) | Success bindings -> { ms_vars = bindings; ms_hyps = [] } in solve_mp_for_hyps #a problem.mp_hyps hypotheses body goal_ps /// A DSL for pattern-matching /// ========================== /// /// Using pattern-matching problems as defined above is relatively cumbersome, /// so we now introduce a lightweight notation, in two steps: pattern notations, /// and matching-problem notations. /// /// Pattern notations /// ----------------- /// /// The first part of our pattern-matching syntax is pattern notations: we /// provide a reflective function which constructs a pattern from a term: /// variables are holes, free variables are constants, and applications are /// application patterns. (* FIXME: MOVE *) let name_of_namedv (x:namedv) : Tac string = unseal (inspect_namedv x).ppname (** Compile a term `tm` into a pattern. **) let rec pattern_of_term_ex tm : Tac (match_res pattern) = match inspect tm with | Tv_Var bv -> return (PVar (name_of_namedv bv)) | Tv_FVar fv | Tv_UInst fv _ -> let qn = fv_to_string fv in return (PQn qn) | Tv_Type _ -> return PType | Tv_App f (x, _) -> let? fpat = pattern_of_term_ex f in let? xpat = pattern_of_term_ex x in return (PApp fpat xpat) | _ -> raise (UnsupportedTermInPattern tm) (** β-reduce a term `tm`. This is useful to remove needles function applications introduced by F*, like ``(fun a b c -> a) 1 2 3``. **) let beta_reduce (tm: term) : Tac term = norm_term [] tm (** Compile a term `tm` into a pattern. **) let pattern_of_term tm : Tac pattern = match pattern_of_term_ex tm with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Problem notations /// ----------------- /// /// We then introduce a DSL for matching problems, best explained on the /// following example:: /// /// (fun (a b c: ①) (h1 h2 h3: hyp ②) (g: pm_goal ③) → ④) /// /// This notation is intended to express a pattern-matching problems with three /// holes ``a``, ``b``, and ``c`` of type ①, matching hypotheses ``h1``, ``h2``, /// and ``h3`` against pattern ② and the goal against the pattern ③. The body /// of the notation (④) is then run with appropriate terms bound to ``a``, /// ``b``, and ``c``, appropriate binders bound to ``h1``, ``h2``, and ``h3``, /// and ``()`` bound to ``g``. /// /// We call these patterns ``abspat``s (abstraction patterns), and we provide /// facilities to parse them into matching problems, and to run their bodies /// against a particular matching solution. // We used to annotate variables with an explicit 'var' marker, but then that // var annotation leaked into the types of other hypotheses due to type // inference, requiring non-trivial normalization. // let var (a: Type) = a let hyp (a: Type) = binding let pm_goal (a: Type) = unit

Prims.string

Prims.Tot

let hyp_qn =

`%hyp

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.goal_qn

val goal_qn : Prims.string

let goal_qn = `%pm_goal

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp" let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)" /// The exception monad /// ------------------- noeq type match_res a = | Success of a | Failure of match_exception let return #a (x: a) : match_res a = Success x let (let?) (#a #b: Type) (f: match_res a) (g: a -> Tac (match_res b)) : Tac (match_res b) = match f with | Success aa -> g aa | Failure ex -> Failure ex let raise #a (ex: match_exception) : match_res a = Failure ex /// Liftings /// -------- /// /// There's a natural lifting from the exception monad into the tactic effect: let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern interpretation /// ====================== /// /// This section implement pattern-matching. This is strictly a one term, one /// pattern implementation — handling cases in which mutliple hypotheses match /// the same pattern is done later. type bindings = list (varname * term) let string_of_bindings (bindings: bindings) = String.concat "\n" (map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm)) bindings) (** Match a pattern against a term. `cur_bindings` is a list of bindings collected while matching previous parts of the pattern. Returns a result in the exception monad. **) let rec interp_pattern_aux (pat: pattern) (cur_bindings: bindings) (tm:term) : Tac (match_res bindings) = let interp_var (v: varname) cur_bindings tm = match List.Tot.Base.assoc v cur_bindings with | Some tm' -> if term_eq tm tm' then return cur_bindings else raise (NonLinearMismatch (v, tm, tm')) | None -> return ((v, tm) :: cur_bindings) in let interp_qn (qn: qn) cur_bindings tm = match inspect tm with | Tv_UInst fv _ | Tv_FVar fv -> if fv_to_string fv = qn then return cur_bindings else raise (NameMismatch (qn, (fv_to_string fv))) | _ -> raise (SimpleMismatch (pat, tm)) in let interp_type cur_bindings tm = match inspect tm with | Tv_Type _ -> return cur_bindings | _ -> raise (SimpleMismatch (pat, tm)) in let interp_app (p_hd p_arg: (p:pattern{p << pat})) cur_bindings tm = match inspect tm with | Tv_App hd (arg, _) -> let? with_hd = interp_pattern_aux p_hd cur_bindings hd in let? with_arg = interp_pattern_aux p_arg with_hd arg in return with_arg | _ -> raise (SimpleMismatch (pat, tm)) in match pat with | PVar var -> interp_var var cur_bindings tm | PQn qn -> interp_qn qn cur_bindings tm | PType -> interp_type cur_bindings tm | PApp p_hd p_arg -> interp_app p_hd p_arg cur_bindings tm (** Match a pattern `pat` against a term. Returns a result in the exception monad. **) let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) = fun (tm: term) -> let? rev_bindings = interp_pattern_aux pat [] tm in return (List.Tot.Base.rev rev_bindings) (** Match a term `tm` against a pattern `pat`. Raises an exception if the match fails. This is mostly useful for debugging: use ``mgw`` to capture matches. **) let match_term pat (tm : term) : Tac bindings = match interp_pattern pat (norm_term [] tm) with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern-matching problems /// ========================= /// /// Generalizing past single-term single-pattern problems, we obtain the /// following notions of pattern-matching problems and solutions: let debug msg : Tac unit = () // print msg /// Definitions /// ----------- let absvar = binding type hypothesis = binding /// A matching problem is composed of holes (``mp_vars``), hypothesis patterns /// (``mp_hyps``), and a goal pattern (``mp_goal``). noeq type matching_problem = { mp_vars: list varname; mp_hyps: list (varname * pattern); mp_goal: option pattern } let string_of_matching_problem mp = let vars = String.concat ", " mp.mp_vars in let hyps = String.concat "\n " (List.Tot.Base.map (fun (nm, pat) -> nm ^ ": " ^ (string_of_pattern pat)) mp.mp_hyps) in let goal = match mp.mp_goal with | None -> "_" | Some pat -> string_of_pattern pat in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ "\n" ^ " goal: " ^ goal ^ " }" /// A solution is composed of terms captured to mach the holes, and binders /// captured to match hypothesis patterns. noeq type matching_solution = { ms_vars: list (varname * term); ms_hyps: list (varname * hypothesis) } let string_of_matching_solution ms = let vars = String.concat "\n " (map (fun (varname, tm) -> varname ^ ": " ^ (term_to_string tm)) ms.ms_vars) in let hyps = String.concat "\n " (map (fun (nm, binding) -> nm ^ ": " ^ (binding_to_string binding)) ms.ms_hyps) in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ " }" (** Find a varname in an association list; fail if it can't be found. **) let assoc_varname_fail (#b: Type) (key: varname) (ls: list (varname * b)) : Tac b = match List.Tot.Base.assoc key ls with | None -> fail ("Not found: " ^ key) | Some x -> x let ms_locate_hyp (a: Type) (solution: matching_solution) (name: varname) : Tac hypothesis = assoc_varname_fail name solution.ms_hyps let ms_locate_var (a: Type) (solution: matching_solution) (name: varname) : Tac a = unquote #a (assoc_varname_fail name solution.ms_vars) let ms_locate_unit (a: Type) _solution _binder_name : Tac unit = () /// Resolution /// ---------- /// /// Solving a matching problem is a two-steps process: find an initial /// assignment for holes based on the goal pattern, then find a set of /// hypotheses matching hypothesis patterns. /// /// Note that the implementation takes a continuation of type /// ``matching_solution -> Tac a``. This continuation is needed because we want /// users to be able to provide extra criteria on matching solutions (most /// commonly, this criterion is that a particular tactic should run /// successfuly). /// /// This makes it easy to implement a simple for of search through the context, /// where one can find a hypothesis matching a particular predicate by /// constructing a trivial matching problem and passing the predicate as the /// continuation. (** Scan ``hypotheses`` for a match for ``pat`` that lets ``body`` succeed. ``name`` is used to refer to the hypothesis matched in the final solution. ``part_sol`` includes bindings gathered while matching previous solutions. **) let rec solve_mp_for_single_hyp #a (name: varname) (pat: pattern) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (part_sol: matching_solution) : Tac a = match hypotheses with | [] -> fail #a "No matching hypothesis" | h :: hs -> or_else // Must be in ``Tac`` here to run `body` (fun () -> match interp_pattern_aux pat part_sol.ms_vars (type_of_binding h) with | Failure ex -> fail ("Failed to match hyp: " ^ (string_of_match_exception ex)) | Success bindings -> let ms_hyps = (name, h) :: part_sol.ms_hyps in body ({ part_sol with ms_vars = bindings; ms_hyps = ms_hyps })) (fun () -> solve_mp_for_single_hyp name pat hs body part_sol) (** Scan ``hypotheses`` for matches for ``mp_hyps`` that lets ``body`` succeed. **) let rec solve_mp_for_hyps #a (mp_hyps: list (varname * pattern)) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (partial_solution: matching_solution) : Tac a = match mp_hyps with | [] -> body partial_solution | (name, pat) :: pats -> solve_mp_for_single_hyp name pat hypotheses (solve_mp_for_hyps pats hypotheses body) partial_solution (** Solve a matching problem. The solution returned is constructed to ensure that the continuation ``body`` succeeds: this implements the usual backtracking-match semantics. **) let solve_mp #a (problem: matching_problem) (hypotheses: list hypothesis) (goal: term) (body: matching_solution -> Tac a) : Tac a = let goal_ps = match problem.mp_goal with | None -> { ms_vars = []; ms_hyps = [] } | Some pat -> match interp_pattern pat goal with | Failure ex -> fail ("Failed to match goal: " ^ (string_of_match_exception ex)) | Success bindings -> { ms_vars = bindings; ms_hyps = [] } in solve_mp_for_hyps #a problem.mp_hyps hypotheses body goal_ps /// A DSL for pattern-matching /// ========================== /// /// Using pattern-matching problems as defined above is relatively cumbersome, /// so we now introduce a lightweight notation, in two steps: pattern notations, /// and matching-problem notations. /// /// Pattern notations /// ----------------- /// /// The first part of our pattern-matching syntax is pattern notations: we /// provide a reflective function which constructs a pattern from a term: /// variables are holes, free variables are constants, and applications are /// application patterns. (* FIXME: MOVE *) let name_of_namedv (x:namedv) : Tac string = unseal (inspect_namedv x).ppname (** Compile a term `tm` into a pattern. **) let rec pattern_of_term_ex tm : Tac (match_res pattern) = match inspect tm with | Tv_Var bv -> return (PVar (name_of_namedv bv)) | Tv_FVar fv | Tv_UInst fv _ -> let qn = fv_to_string fv in return (PQn qn) | Tv_Type _ -> return PType | Tv_App f (x, _) -> let? fpat = pattern_of_term_ex f in let? xpat = pattern_of_term_ex x in return (PApp fpat xpat) | _ -> raise (UnsupportedTermInPattern tm) (** β-reduce a term `tm`. This is useful to remove needles function applications introduced by F*, like ``(fun a b c -> a) 1 2 3``. **) let beta_reduce (tm: term) : Tac term = norm_term [] tm (** Compile a term `tm` into a pattern. **) let pattern_of_term tm : Tac pattern = match pattern_of_term_ex tm with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Problem notations /// ----------------- /// /// We then introduce a DSL for matching problems, best explained on the /// following example:: /// /// (fun (a b c: ①) (h1 h2 h3: hyp ②) (g: pm_goal ③) → ④) /// /// This notation is intended to express a pattern-matching problems with three /// holes ``a``, ``b``, and ``c`` of type ①, matching hypotheses ``h1``, ``h2``, /// and ``h3`` against pattern ② and the goal against the pattern ③. The body /// of the notation (④) is then run with appropriate terms bound to ``a``, /// ``b``, and ``c``, appropriate binders bound to ``h1``, ``h2``, and ``h3``, /// and ``()`` bound to ``g``. /// /// We call these patterns ``abspat``s (abstraction patterns), and we provide /// facilities to parse them into matching problems, and to run their bodies /// against a particular matching solution. // We used to annotate variables with an explicit 'var' marker, but then that // var annotation leaked into the types of other hypotheses due to type // inference, requiring non-trivial normalization. // let var (a: Type) = a let hyp (a: Type) = binding let pm_goal (a: Type) = unit

Prims.string

Prims.Tot

let goal_qn =

`%pm_goal

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.pm_goal

val pm_goal : a: Type -> Prims.eqtype

let pm_goal (a: Type) = unit

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp" let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)" /// The exception monad /// ------------------- noeq type match_res a = | Success of a | Failure of match_exception let return #a (x: a) : match_res a = Success x let (let?) (#a #b: Type) (f: match_res a) (g: a -> Tac (match_res b)) : Tac (match_res b) = match f with | Success aa -> g aa | Failure ex -> Failure ex let raise #a (ex: match_exception) : match_res a = Failure ex /// Liftings /// -------- /// /// There's a natural lifting from the exception monad into the tactic effect: let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern interpretation /// ====================== /// /// This section implement pattern-matching. This is strictly a one term, one /// pattern implementation — handling cases in which mutliple hypotheses match /// the same pattern is done later. type bindings = list (varname * term) let string_of_bindings (bindings: bindings) = String.concat "\n" (map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm)) bindings) (** Match a pattern against a term. `cur_bindings` is a list of bindings collected while matching previous parts of the pattern. Returns a result in the exception monad. **) let rec interp_pattern_aux (pat: pattern) (cur_bindings: bindings) (tm:term) : Tac (match_res bindings) = let interp_var (v: varname) cur_bindings tm = match List.Tot.Base.assoc v cur_bindings with | Some tm' -> if term_eq tm tm' then return cur_bindings else raise (NonLinearMismatch (v, tm, tm')) | None -> return ((v, tm) :: cur_bindings) in let interp_qn (qn: qn) cur_bindings tm = match inspect tm with | Tv_UInst fv _ | Tv_FVar fv -> if fv_to_string fv = qn then return cur_bindings else raise (NameMismatch (qn, (fv_to_string fv))) | _ -> raise (SimpleMismatch (pat, tm)) in let interp_type cur_bindings tm = match inspect tm with | Tv_Type _ -> return cur_bindings | _ -> raise (SimpleMismatch (pat, tm)) in let interp_app (p_hd p_arg: (p:pattern{p << pat})) cur_bindings tm = match inspect tm with | Tv_App hd (arg, _) -> let? with_hd = interp_pattern_aux p_hd cur_bindings hd in let? with_arg = interp_pattern_aux p_arg with_hd arg in return with_arg | _ -> raise (SimpleMismatch (pat, tm)) in match pat with | PVar var -> interp_var var cur_bindings tm | PQn qn -> interp_qn qn cur_bindings tm | PType -> interp_type cur_bindings tm | PApp p_hd p_arg -> interp_app p_hd p_arg cur_bindings tm (** Match a pattern `pat` against a term. Returns a result in the exception monad. **) let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) = fun (tm: term) -> let? rev_bindings = interp_pattern_aux pat [] tm in return (List.Tot.Base.rev rev_bindings) (** Match a term `tm` against a pattern `pat`. Raises an exception if the match fails. This is mostly useful for debugging: use ``mgw`` to capture matches. **) let match_term pat (tm : term) : Tac bindings = match interp_pattern pat (norm_term [] tm) with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern-matching problems /// ========================= /// /// Generalizing past single-term single-pattern problems, we obtain the /// following notions of pattern-matching problems and solutions: let debug msg : Tac unit = () // print msg /// Definitions /// ----------- let absvar = binding type hypothesis = binding /// A matching problem is composed of holes (``mp_vars``), hypothesis patterns /// (``mp_hyps``), and a goal pattern (``mp_goal``). noeq type matching_problem = { mp_vars: list varname; mp_hyps: list (varname * pattern); mp_goal: option pattern } let string_of_matching_problem mp = let vars = String.concat ", " mp.mp_vars in let hyps = String.concat "\n " (List.Tot.Base.map (fun (nm, pat) -> nm ^ ": " ^ (string_of_pattern pat)) mp.mp_hyps) in let goal = match mp.mp_goal with | None -> "_" | Some pat -> string_of_pattern pat in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ "\n" ^ " goal: " ^ goal ^ " }" /// A solution is composed of terms captured to mach the holes, and binders /// captured to match hypothesis patterns. noeq type matching_solution = { ms_vars: list (varname * term); ms_hyps: list (varname * hypothesis) } let string_of_matching_solution ms = let vars = String.concat "\n " (map (fun (varname, tm) -> varname ^ ": " ^ (term_to_string tm)) ms.ms_vars) in let hyps = String.concat "\n " (map (fun (nm, binding) -> nm ^ ": " ^ (binding_to_string binding)) ms.ms_hyps) in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ " }" (** Find a varname in an association list; fail if it can't be found. **) let assoc_varname_fail (#b: Type) (key: varname) (ls: list (varname * b)) : Tac b = match List.Tot.Base.assoc key ls with | None -> fail ("Not found: " ^ key) | Some x -> x let ms_locate_hyp (a: Type) (solution: matching_solution) (name: varname) : Tac hypothesis = assoc_varname_fail name solution.ms_hyps let ms_locate_var (a: Type) (solution: matching_solution) (name: varname) : Tac a = unquote #a (assoc_varname_fail name solution.ms_vars) let ms_locate_unit (a: Type) _solution _binder_name : Tac unit = () /// Resolution /// ---------- /// /// Solving a matching problem is a two-steps process: find an initial /// assignment for holes based on the goal pattern, then find a set of /// hypotheses matching hypothesis patterns. /// /// Note that the implementation takes a continuation of type /// ``matching_solution -> Tac a``. This continuation is needed because we want /// users to be able to provide extra criteria on matching solutions (most /// commonly, this criterion is that a particular tactic should run /// successfuly). /// /// This makes it easy to implement a simple for of search through the context, /// where one can find a hypothesis matching a particular predicate by /// constructing a trivial matching problem and passing the predicate as the /// continuation. (** Scan ``hypotheses`` for a match for ``pat`` that lets ``body`` succeed. ``name`` is used to refer to the hypothesis matched in the final solution. ``part_sol`` includes bindings gathered while matching previous solutions. **) let rec solve_mp_for_single_hyp #a (name: varname) (pat: pattern) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (part_sol: matching_solution) : Tac a = match hypotheses with | [] -> fail #a "No matching hypothesis" | h :: hs -> or_else // Must be in ``Tac`` here to run `body` (fun () -> match interp_pattern_aux pat part_sol.ms_vars (type_of_binding h) with | Failure ex -> fail ("Failed to match hyp: " ^ (string_of_match_exception ex)) | Success bindings -> let ms_hyps = (name, h) :: part_sol.ms_hyps in body ({ part_sol with ms_vars = bindings; ms_hyps = ms_hyps })) (fun () -> solve_mp_for_single_hyp name pat hs body part_sol) (** Scan ``hypotheses`` for matches for ``mp_hyps`` that lets ``body`` succeed. **) let rec solve_mp_for_hyps #a (mp_hyps: list (varname * pattern)) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (partial_solution: matching_solution) : Tac a = match mp_hyps with | [] -> body partial_solution | (name, pat) :: pats -> solve_mp_for_single_hyp name pat hypotheses (solve_mp_for_hyps pats hypotheses body) partial_solution (** Solve a matching problem. The solution returned is constructed to ensure that the continuation ``body`` succeeds: this implements the usual backtracking-match semantics. **) let solve_mp #a (problem: matching_problem) (hypotheses: list hypothesis) (goal: term) (body: matching_solution -> Tac a) : Tac a = let goal_ps = match problem.mp_goal with | None -> { ms_vars = []; ms_hyps = [] } | Some pat -> match interp_pattern pat goal with | Failure ex -> fail ("Failed to match goal: " ^ (string_of_match_exception ex)) | Success bindings -> { ms_vars = bindings; ms_hyps = [] } in solve_mp_for_hyps #a problem.mp_hyps hypotheses body goal_ps /// A DSL for pattern-matching /// ========================== /// /// Using pattern-matching problems as defined above is relatively cumbersome, /// so we now introduce a lightweight notation, in two steps: pattern notations, /// and matching-problem notations. /// /// Pattern notations /// ----------------- /// /// The first part of our pattern-matching syntax is pattern notations: we /// provide a reflective function which constructs a pattern from a term: /// variables are holes, free variables are constants, and applications are /// application patterns. (* FIXME: MOVE *) let name_of_namedv (x:namedv) : Tac string = unseal (inspect_namedv x).ppname (** Compile a term `tm` into a pattern. **) let rec pattern_of_term_ex tm : Tac (match_res pattern) = match inspect tm with | Tv_Var bv -> return (PVar (name_of_namedv bv)) | Tv_FVar fv | Tv_UInst fv _ -> let qn = fv_to_string fv in return (PQn qn) | Tv_Type _ -> return PType | Tv_App f (x, _) -> let? fpat = pattern_of_term_ex f in let? xpat = pattern_of_term_ex x in return (PApp fpat xpat) | _ -> raise (UnsupportedTermInPattern tm) (** β-reduce a term `tm`. This is useful to remove needles function applications introduced by F*, like ``(fun a b c -> a) 1 2 3``. **) let beta_reduce (tm: term) : Tac term = norm_term [] tm (** Compile a term `tm` into a pattern. **) let pattern_of_term tm : Tac pattern = match pattern_of_term_ex tm with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Problem notations /// ----------------- /// /// We then introduce a DSL for matching problems, best explained on the /// following example:: /// /// (fun (a b c: ①) (h1 h2 h3: hyp ②) (g: pm_goal ③) → ④) /// /// This notation is intended to express a pattern-matching problems with three /// holes ``a``, ``b``, and ``c`` of type ①, matching hypotheses ``h1``, ``h2``, /// and ``h3`` against pattern ② and the goal against the pattern ③. The body /// of the notation (④) is then run with appropriate terms bound to ``a``, /// ``b``, and ``c``, appropriate binders bound to ``h1``, ``h2``, and ``h3``, /// and ``()`` bound to ``g``. /// /// We call these patterns ``abspat``s (abstraction patterns), and we provide /// facilities to parse them into matching problems, and to run their bodies /// against a particular matching solution. // We used to annotate variables with an explicit 'var' marker, but then that // var annotation leaked into the types of other hypotheses due to type // inference, requiring non-trivial normalization. // let var (a: Type) = a

a: Type -> Prims.eqtype

Prims.Tot

let pm_goal (a: Type) =

unit

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.name_of_namedv

val name_of_namedv (x: namedv) : Tac string

val name_of_namedv (x: namedv) : Tac string

let name_of_namedv (x:namedv) : Tac string = unseal (inspect_namedv x).ppname

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp" let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)" /// The exception monad /// ------------------- noeq type match_res a = | Success of a | Failure of match_exception let return #a (x: a) : match_res a = Success x let (let?) (#a #b: Type) (f: match_res a) (g: a -> Tac (match_res b)) : Tac (match_res b) = match f with | Success aa -> g aa | Failure ex -> Failure ex let raise #a (ex: match_exception) : match_res a = Failure ex /// Liftings /// -------- /// /// There's a natural lifting from the exception monad into the tactic effect: let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern interpretation /// ====================== /// /// This section implement pattern-matching. This is strictly a one term, one /// pattern implementation — handling cases in which mutliple hypotheses match /// the same pattern is done later. type bindings = list (varname * term) let string_of_bindings (bindings: bindings) = String.concat "\n" (map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm)) bindings) (** Match a pattern against a term. `cur_bindings` is a list of bindings collected while matching previous parts of the pattern. Returns a result in the exception monad. **) let rec interp_pattern_aux (pat: pattern) (cur_bindings: bindings) (tm:term) : Tac (match_res bindings) = let interp_var (v: varname) cur_bindings tm = match List.Tot.Base.assoc v cur_bindings with | Some tm' -> if term_eq tm tm' then return cur_bindings else raise (NonLinearMismatch (v, tm, tm')) | None -> return ((v, tm) :: cur_bindings) in let interp_qn (qn: qn) cur_bindings tm = match inspect tm with | Tv_UInst fv _ | Tv_FVar fv -> if fv_to_string fv = qn then return cur_bindings else raise (NameMismatch (qn, (fv_to_string fv))) | _ -> raise (SimpleMismatch (pat, tm)) in let interp_type cur_bindings tm = match inspect tm with | Tv_Type _ -> return cur_bindings | _ -> raise (SimpleMismatch (pat, tm)) in let interp_app (p_hd p_arg: (p:pattern{p << pat})) cur_bindings tm = match inspect tm with | Tv_App hd (arg, _) -> let? with_hd = interp_pattern_aux p_hd cur_bindings hd in let? with_arg = interp_pattern_aux p_arg with_hd arg in return with_arg | _ -> raise (SimpleMismatch (pat, tm)) in match pat with | PVar var -> interp_var var cur_bindings tm | PQn qn -> interp_qn qn cur_bindings tm | PType -> interp_type cur_bindings tm | PApp p_hd p_arg -> interp_app p_hd p_arg cur_bindings tm (** Match a pattern `pat` against a term. Returns a result in the exception monad. **) let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) = fun (tm: term) -> let? rev_bindings = interp_pattern_aux pat [] tm in return (List.Tot.Base.rev rev_bindings) (** Match a term `tm` against a pattern `pat`. Raises an exception if the match fails. This is mostly useful for debugging: use ``mgw`` to capture matches. **) let match_term pat (tm : term) : Tac bindings = match interp_pattern pat (norm_term [] tm) with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern-matching problems /// ========================= /// /// Generalizing past single-term single-pattern problems, we obtain the /// following notions of pattern-matching problems and solutions: let debug msg : Tac unit = () // print msg /// Definitions /// ----------- let absvar = binding type hypothesis = binding /// A matching problem is composed of holes (``mp_vars``), hypothesis patterns /// (``mp_hyps``), and a goal pattern (``mp_goal``). noeq type matching_problem = { mp_vars: list varname; mp_hyps: list (varname * pattern); mp_goal: option pattern } let string_of_matching_problem mp = let vars = String.concat ", " mp.mp_vars in let hyps = String.concat "\n " (List.Tot.Base.map (fun (nm, pat) -> nm ^ ": " ^ (string_of_pattern pat)) mp.mp_hyps) in let goal = match mp.mp_goal with | None -> "_" | Some pat -> string_of_pattern pat in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ "\n" ^ " goal: " ^ goal ^ " }" /// A solution is composed of terms captured to mach the holes, and binders /// captured to match hypothesis patterns. noeq type matching_solution = { ms_vars: list (varname * term); ms_hyps: list (varname * hypothesis) } let string_of_matching_solution ms = let vars = String.concat "\n " (map (fun (varname, tm) -> varname ^ ": " ^ (term_to_string tm)) ms.ms_vars) in let hyps = String.concat "\n " (map (fun (nm, binding) -> nm ^ ": " ^ (binding_to_string binding)) ms.ms_hyps) in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ " }" (** Find a varname in an association list; fail if it can't be found. **) let assoc_varname_fail (#b: Type) (key: varname) (ls: list (varname * b)) : Tac b = match List.Tot.Base.assoc key ls with | None -> fail ("Not found: " ^ key) | Some x -> x let ms_locate_hyp (a: Type) (solution: matching_solution) (name: varname) : Tac hypothesis = assoc_varname_fail name solution.ms_hyps let ms_locate_var (a: Type) (solution: matching_solution) (name: varname) : Tac a = unquote #a (assoc_varname_fail name solution.ms_vars) let ms_locate_unit (a: Type) _solution _binder_name : Tac unit = () /// Resolution /// ---------- /// /// Solving a matching problem is a two-steps process: find an initial /// assignment for holes based on the goal pattern, then find a set of /// hypotheses matching hypothesis patterns. /// /// Note that the implementation takes a continuation of type /// ``matching_solution -> Tac a``. This continuation is needed because we want /// users to be able to provide extra criteria on matching solutions (most /// commonly, this criterion is that a particular tactic should run /// successfuly). /// /// This makes it easy to implement a simple for of search through the context, /// where one can find a hypothesis matching a particular predicate by /// constructing a trivial matching problem and passing the predicate as the /// continuation. (** Scan ``hypotheses`` for a match for ``pat`` that lets ``body`` succeed. ``name`` is used to refer to the hypothesis matched in the final solution. ``part_sol`` includes bindings gathered while matching previous solutions. **) let rec solve_mp_for_single_hyp #a (name: varname) (pat: pattern) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (part_sol: matching_solution) : Tac a = match hypotheses with | [] -> fail #a "No matching hypothesis" | h :: hs -> or_else // Must be in ``Tac`` here to run `body` (fun () -> match interp_pattern_aux pat part_sol.ms_vars (type_of_binding h) with | Failure ex -> fail ("Failed to match hyp: " ^ (string_of_match_exception ex)) | Success bindings -> let ms_hyps = (name, h) :: part_sol.ms_hyps in body ({ part_sol with ms_vars = bindings; ms_hyps = ms_hyps })) (fun () -> solve_mp_for_single_hyp name pat hs body part_sol) (** Scan ``hypotheses`` for matches for ``mp_hyps`` that lets ``body`` succeed. **) let rec solve_mp_for_hyps #a (mp_hyps: list (varname * pattern)) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (partial_solution: matching_solution) : Tac a = match mp_hyps with | [] -> body partial_solution | (name, pat) :: pats -> solve_mp_for_single_hyp name pat hypotheses (solve_mp_for_hyps pats hypotheses body) partial_solution (** Solve a matching problem. The solution returned is constructed to ensure that the continuation ``body`` succeeds: this implements the usual backtracking-match semantics. **) let solve_mp #a (problem: matching_problem) (hypotheses: list hypothesis) (goal: term) (body: matching_solution -> Tac a) : Tac a = let goal_ps = match problem.mp_goal with | None -> { ms_vars = []; ms_hyps = [] } | Some pat -> match interp_pattern pat goal with | Failure ex -> fail ("Failed to match goal: " ^ (string_of_match_exception ex)) | Success bindings -> { ms_vars = bindings; ms_hyps = [] } in solve_mp_for_hyps #a problem.mp_hyps hypotheses body goal_ps /// A DSL for pattern-matching /// ========================== /// /// Using pattern-matching problems as defined above is relatively cumbersome, /// so we now introduce a lightweight notation, in two steps: pattern notations, /// and matching-problem notations. /// /// Pattern notations /// ----------------- /// /// The first part of our pattern-matching syntax is pattern notations: we /// provide a reflective function which constructs a pattern from a term: /// variables are holes, free variables are constants, and applications are /// application patterns.

x: FStar.Tactics.NamedView.namedv -> FStar.Tactics.Effect.Tac Prims.string

FStar.Tactics.Effect.Tac

let name_of_namedv (x: namedv) : Tac string =

unseal (inspect_namedv x).ppname

MerkleTree.Spec.fst

MerkleTree.Spec.hashes

val hashes (#hsz:pos): Type0

val hashes (#hsz:pos): Type0

let hashes #hsz = S.seq (padded_hash #hsz)

module MerkleTree.Spec open FStar.Classical open FStar.Mul open FStar.Seq module S = FStar.Seq #set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10" // For SHA2_256, this is is a sequence of 32 bytes // These are secret bytes, hence not an eqtype type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz } type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz) val sha256_compress: hash_fun_t #32 let sha256_compress src1 src2 = let sz = Spec.Hash.Definitions.SHA2_256 in let hash_alg = Spec.Hash.Definitions.SHA2_256 in let acc = Spec.Agile.Hash.init hash_alg in let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in Spec.Agile.Hash.finish hash_alg acc () /// For simplicity, we will specify the root for a sequence of [i] /// tags where [i <= 2^n] as the root of a full binary tree with [2^n] /// leaves obtained by padding the sequence with dummies. This /// requires extending the definitions of hashes and hash functions. Our /// extended definition of hash justifies skipping any concrete /// computation on dummies. noeq type padded_hash #hsz = | HRaw: hr:hash #hsz -> padded_hash #hsz | HPad // right padding to make the size of a Merkle tree a power of 2 val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz) let padded_hash_fun #hsz f lh rh = allow_inversion (padded_hash #hsz); match lh, rh with | HPad , _ -> HPad | _ , HPad -> lh | HRaw lhr, HRaw rhr -> HRaw (f lhr rhr) noextract

Type0

Prims.Tot

let hashes #hsz =

S.seq (padded_hash #hsz)

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.hyp

val hyp : a: Type -> Type0

let hyp (a: Type) = binding

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp" let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)" /// The exception monad /// ------------------- noeq type match_res a = | Success of a | Failure of match_exception let return #a (x: a) : match_res a = Success x let (let?) (#a #b: Type) (f: match_res a) (g: a -> Tac (match_res b)) : Tac (match_res b) = match f with | Success aa -> g aa | Failure ex -> Failure ex let raise #a (ex: match_exception) : match_res a = Failure ex /// Liftings /// -------- /// /// There's a natural lifting from the exception monad into the tactic effect: let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern interpretation /// ====================== /// /// This section implement pattern-matching. This is strictly a one term, one /// pattern implementation — handling cases in which mutliple hypotheses match /// the same pattern is done later. type bindings = list (varname * term) let string_of_bindings (bindings: bindings) = String.concat "\n" (map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm)) bindings) (** Match a pattern against a term. `cur_bindings` is a list of bindings collected while matching previous parts of the pattern. Returns a result in the exception monad. **) let rec interp_pattern_aux (pat: pattern) (cur_bindings: bindings) (tm:term) : Tac (match_res bindings) = let interp_var (v: varname) cur_bindings tm = match List.Tot.Base.assoc v cur_bindings with | Some tm' -> if term_eq tm tm' then return cur_bindings else raise (NonLinearMismatch (v, tm, tm')) | None -> return ((v, tm) :: cur_bindings) in let interp_qn (qn: qn) cur_bindings tm = match inspect tm with | Tv_UInst fv _ | Tv_FVar fv -> if fv_to_string fv = qn then return cur_bindings else raise (NameMismatch (qn, (fv_to_string fv))) | _ -> raise (SimpleMismatch (pat, tm)) in let interp_type cur_bindings tm = match inspect tm with | Tv_Type _ -> return cur_bindings | _ -> raise (SimpleMismatch (pat, tm)) in let interp_app (p_hd p_arg: (p:pattern{p << pat})) cur_bindings tm = match inspect tm with | Tv_App hd (arg, _) -> let? with_hd = interp_pattern_aux p_hd cur_bindings hd in let? with_arg = interp_pattern_aux p_arg with_hd arg in return with_arg | _ -> raise (SimpleMismatch (pat, tm)) in match pat with | PVar var -> interp_var var cur_bindings tm | PQn qn -> interp_qn qn cur_bindings tm | PType -> interp_type cur_bindings tm | PApp p_hd p_arg -> interp_app p_hd p_arg cur_bindings tm (** Match a pattern `pat` against a term. Returns a result in the exception monad. **) let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) = fun (tm: term) -> let? rev_bindings = interp_pattern_aux pat [] tm in return (List.Tot.Base.rev rev_bindings) (** Match a term `tm` against a pattern `pat`. Raises an exception if the match fails. This is mostly useful for debugging: use ``mgw`` to capture matches. **) let match_term pat (tm : term) : Tac bindings = match interp_pattern pat (norm_term [] tm) with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern-matching problems /// ========================= /// /// Generalizing past single-term single-pattern problems, we obtain the /// following notions of pattern-matching problems and solutions: let debug msg : Tac unit = () // print msg /// Definitions /// ----------- let absvar = binding type hypothesis = binding /// A matching problem is composed of holes (``mp_vars``), hypothesis patterns /// (``mp_hyps``), and a goal pattern (``mp_goal``). noeq type matching_problem = { mp_vars: list varname; mp_hyps: list (varname * pattern); mp_goal: option pattern } let string_of_matching_problem mp = let vars = String.concat ", " mp.mp_vars in let hyps = String.concat "\n " (List.Tot.Base.map (fun (nm, pat) -> nm ^ ": " ^ (string_of_pattern pat)) mp.mp_hyps) in let goal = match mp.mp_goal with | None -> "_" | Some pat -> string_of_pattern pat in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ "\n" ^ " goal: " ^ goal ^ " }" /// A solution is composed of terms captured to mach the holes, and binders /// captured to match hypothesis patterns. noeq type matching_solution = { ms_vars: list (varname * term); ms_hyps: list (varname * hypothesis) } let string_of_matching_solution ms = let vars = String.concat "\n " (map (fun (varname, tm) -> varname ^ ": " ^ (term_to_string tm)) ms.ms_vars) in let hyps = String.concat "\n " (map (fun (nm, binding) -> nm ^ ": " ^ (binding_to_string binding)) ms.ms_hyps) in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ " }" (** Find a varname in an association list; fail if it can't be found. **) let assoc_varname_fail (#b: Type) (key: varname) (ls: list (varname * b)) : Tac b = match List.Tot.Base.assoc key ls with | None -> fail ("Not found: " ^ key) | Some x -> x let ms_locate_hyp (a: Type) (solution: matching_solution) (name: varname) : Tac hypothesis = assoc_varname_fail name solution.ms_hyps let ms_locate_var (a: Type) (solution: matching_solution) (name: varname) : Tac a = unquote #a (assoc_varname_fail name solution.ms_vars) let ms_locate_unit (a: Type) _solution _binder_name : Tac unit = () /// Resolution /// ---------- /// /// Solving a matching problem is a two-steps process: find an initial /// assignment for holes based on the goal pattern, then find a set of /// hypotheses matching hypothesis patterns. /// /// Note that the implementation takes a continuation of type /// ``matching_solution -> Tac a``. This continuation is needed because we want /// users to be able to provide extra criteria on matching solutions (most /// commonly, this criterion is that a particular tactic should run /// successfuly). /// /// This makes it easy to implement a simple for of search through the context, /// where one can find a hypothesis matching a particular predicate by /// constructing a trivial matching problem and passing the predicate as the /// continuation. (** Scan ``hypotheses`` for a match for ``pat`` that lets ``body`` succeed. ``name`` is used to refer to the hypothesis matched in the final solution. ``part_sol`` includes bindings gathered while matching previous solutions. **) let rec solve_mp_for_single_hyp #a (name: varname) (pat: pattern) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (part_sol: matching_solution) : Tac a = match hypotheses with | [] -> fail #a "No matching hypothesis" | h :: hs -> or_else // Must be in ``Tac`` here to run `body` (fun () -> match interp_pattern_aux pat part_sol.ms_vars (type_of_binding h) with | Failure ex -> fail ("Failed to match hyp: " ^ (string_of_match_exception ex)) | Success bindings -> let ms_hyps = (name, h) :: part_sol.ms_hyps in body ({ part_sol with ms_vars = bindings; ms_hyps = ms_hyps })) (fun () -> solve_mp_for_single_hyp name pat hs body part_sol) (** Scan ``hypotheses`` for matches for ``mp_hyps`` that lets ``body`` succeed. **) let rec solve_mp_for_hyps #a (mp_hyps: list (varname * pattern)) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (partial_solution: matching_solution) : Tac a = match mp_hyps with | [] -> body partial_solution | (name, pat) :: pats -> solve_mp_for_single_hyp name pat hypotheses (solve_mp_for_hyps pats hypotheses body) partial_solution (** Solve a matching problem. The solution returned is constructed to ensure that the continuation ``body`` succeeds: this implements the usual backtracking-match semantics. **) let solve_mp #a (problem: matching_problem) (hypotheses: list hypothesis) (goal: term) (body: matching_solution -> Tac a) : Tac a = let goal_ps = match problem.mp_goal with | None -> { ms_vars = []; ms_hyps = [] } | Some pat -> match interp_pattern pat goal with | Failure ex -> fail ("Failed to match goal: " ^ (string_of_match_exception ex)) | Success bindings -> { ms_vars = bindings; ms_hyps = [] } in solve_mp_for_hyps #a problem.mp_hyps hypotheses body goal_ps /// A DSL for pattern-matching /// ========================== /// /// Using pattern-matching problems as defined above is relatively cumbersome, /// so we now introduce a lightweight notation, in two steps: pattern notations, /// and matching-problem notations. /// /// Pattern notations /// ----------------- /// /// The first part of our pattern-matching syntax is pattern notations: we /// provide a reflective function which constructs a pattern from a term: /// variables are holes, free variables are constants, and applications are /// application patterns. (* FIXME: MOVE *) let name_of_namedv (x:namedv) : Tac string = unseal (inspect_namedv x).ppname (** Compile a term `tm` into a pattern. **) let rec pattern_of_term_ex tm : Tac (match_res pattern) = match inspect tm with | Tv_Var bv -> return (PVar (name_of_namedv bv)) | Tv_FVar fv | Tv_UInst fv _ -> let qn = fv_to_string fv in return (PQn qn) | Tv_Type _ -> return PType | Tv_App f (x, _) -> let? fpat = pattern_of_term_ex f in let? xpat = pattern_of_term_ex x in return (PApp fpat xpat) | _ -> raise (UnsupportedTermInPattern tm) (** β-reduce a term `tm`. This is useful to remove needles function applications introduced by F*, like ``(fun a b c -> a) 1 2 3``. **) let beta_reduce (tm: term) : Tac term = norm_term [] tm (** Compile a term `tm` into a pattern. **) let pattern_of_term tm : Tac pattern = match pattern_of_term_ex tm with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Problem notations /// ----------------- /// /// We then introduce a DSL for matching problems, best explained on the /// following example:: /// /// (fun (a b c: ①) (h1 h2 h3: hyp ②) (g: pm_goal ③) → ④) /// /// This notation is intended to express a pattern-matching problems with three /// holes ``a``, ``b``, and ``c`` of type ①, matching hypotheses ``h1``, ``h2``, /// and ``h3`` against pattern ② and the goal against the pattern ③. The body /// of the notation (④) is then run with appropriate terms bound to ``a``, /// ``b``, and ``c``, appropriate binders bound to ``h1``, ``h2``, and ``h3``, /// and ``()`` bound to ``g``. /// /// We call these patterns ``abspat``s (abstraction patterns), and we provide /// facilities to parse them into matching problems, and to run their bodies /// against a particular matching solution. // We used to annotate variables with an explicit 'var' marker, but then that // var annotation leaked into the types of other hypotheses due to type // inference, requiring non-trivial normalization.

a: Type -> Type0

Prims.Tot

let hyp (a: Type) =

binding

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.type_of_named_binder

val type_of_named_binder (nb: binder) : term

val type_of_named_binder (nb: binder) : term

let type_of_named_binder (nb : binder) : term = nb.sort

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp" let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)" /// The exception monad /// ------------------- noeq type match_res a = | Success of a | Failure of match_exception let return #a (x: a) : match_res a = Success x let (let?) (#a #b: Type) (f: match_res a) (g: a -> Tac (match_res b)) : Tac (match_res b) = match f with | Success aa -> g aa | Failure ex -> Failure ex let raise #a (ex: match_exception) : match_res a = Failure ex /// Liftings /// -------- /// /// There's a natural lifting from the exception monad into the tactic effect: let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern interpretation /// ====================== /// /// This section implement pattern-matching. This is strictly a one term, one /// pattern implementation — handling cases in which mutliple hypotheses match /// the same pattern is done later. type bindings = list (varname * term) let string_of_bindings (bindings: bindings) = String.concat "\n" (map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm)) bindings) (** Match a pattern against a term. `cur_bindings` is a list of bindings collected while matching previous parts of the pattern. Returns a result in the exception monad. **) let rec interp_pattern_aux (pat: pattern) (cur_bindings: bindings) (tm:term) : Tac (match_res bindings) = let interp_var (v: varname) cur_bindings tm = match List.Tot.Base.assoc v cur_bindings with | Some tm' -> if term_eq tm tm' then return cur_bindings else raise (NonLinearMismatch (v, tm, tm')) | None -> return ((v, tm) :: cur_bindings) in let interp_qn (qn: qn) cur_bindings tm = match inspect tm with | Tv_UInst fv _ | Tv_FVar fv -> if fv_to_string fv = qn then return cur_bindings else raise (NameMismatch (qn, (fv_to_string fv))) | _ -> raise (SimpleMismatch (pat, tm)) in let interp_type cur_bindings tm = match inspect tm with | Tv_Type _ -> return cur_bindings | _ -> raise (SimpleMismatch (pat, tm)) in let interp_app (p_hd p_arg: (p:pattern{p << pat})) cur_bindings tm = match inspect tm with | Tv_App hd (arg, _) -> let? with_hd = interp_pattern_aux p_hd cur_bindings hd in let? with_arg = interp_pattern_aux p_arg with_hd arg in return with_arg | _ -> raise (SimpleMismatch (pat, tm)) in match pat with | PVar var -> interp_var var cur_bindings tm | PQn qn -> interp_qn qn cur_bindings tm | PType -> interp_type cur_bindings tm | PApp p_hd p_arg -> interp_app p_hd p_arg cur_bindings tm (** Match a pattern `pat` against a term. Returns a result in the exception monad. **) let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) = fun (tm: term) -> let? rev_bindings = interp_pattern_aux pat [] tm in return (List.Tot.Base.rev rev_bindings) (** Match a term `tm` against a pattern `pat`. Raises an exception if the match fails. This is mostly useful for debugging: use ``mgw`` to capture matches. **) let match_term pat (tm : term) : Tac bindings = match interp_pattern pat (norm_term [] tm) with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern-matching problems /// ========================= /// /// Generalizing past single-term single-pattern problems, we obtain the /// following notions of pattern-matching problems and solutions: let debug msg : Tac unit = () // print msg /// Definitions /// ----------- let absvar = binding type hypothesis = binding /// A matching problem is composed of holes (``mp_vars``), hypothesis patterns /// (``mp_hyps``), and a goal pattern (``mp_goal``). noeq type matching_problem = { mp_vars: list varname; mp_hyps: list (varname * pattern); mp_goal: option pattern } let string_of_matching_problem mp = let vars = String.concat ", " mp.mp_vars in let hyps = String.concat "\n " (List.Tot.Base.map (fun (nm, pat) -> nm ^ ": " ^ (string_of_pattern pat)) mp.mp_hyps) in let goal = match mp.mp_goal with | None -> "_" | Some pat -> string_of_pattern pat in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ "\n" ^ " goal: " ^ goal ^ " }" /// A solution is composed of terms captured to mach the holes, and binders /// captured to match hypothesis patterns. noeq type matching_solution = { ms_vars: list (varname * term); ms_hyps: list (varname * hypothesis) } let string_of_matching_solution ms = let vars = String.concat "\n " (map (fun (varname, tm) -> varname ^ ": " ^ (term_to_string tm)) ms.ms_vars) in let hyps = String.concat "\n " (map (fun (nm, binding) -> nm ^ ": " ^ (binding_to_string binding)) ms.ms_hyps) in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ " }" (** Find a varname in an association list; fail if it can't be found. **) let assoc_varname_fail (#b: Type) (key: varname) (ls: list (varname * b)) : Tac b = match List.Tot.Base.assoc key ls with | None -> fail ("Not found: " ^ key) | Some x -> x let ms_locate_hyp (a: Type) (solution: matching_solution) (name: varname) : Tac hypothesis = assoc_varname_fail name solution.ms_hyps let ms_locate_var (a: Type) (solution: matching_solution) (name: varname) : Tac a = unquote #a (assoc_varname_fail name solution.ms_vars) let ms_locate_unit (a: Type) _solution _binder_name : Tac unit = () /// Resolution /// ---------- /// /// Solving a matching problem is a two-steps process: find an initial /// assignment for holes based on the goal pattern, then find a set of /// hypotheses matching hypothesis patterns. /// /// Note that the implementation takes a continuation of type /// ``matching_solution -> Tac a``. This continuation is needed because we want /// users to be able to provide extra criteria on matching solutions (most /// commonly, this criterion is that a particular tactic should run /// successfuly). /// /// This makes it easy to implement a simple for of search through the context, /// where one can find a hypothesis matching a particular predicate by /// constructing a trivial matching problem and passing the predicate as the /// continuation. (** Scan ``hypotheses`` for a match for ``pat`` that lets ``body`` succeed. ``name`` is used to refer to the hypothesis matched in the final solution. ``part_sol`` includes bindings gathered while matching previous solutions. **) let rec solve_mp_for_single_hyp #a (name: varname) (pat: pattern) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (part_sol: matching_solution) : Tac a = match hypotheses with | [] -> fail #a "No matching hypothesis" | h :: hs -> or_else // Must be in ``Tac`` here to run `body` (fun () -> match interp_pattern_aux pat part_sol.ms_vars (type_of_binding h) with | Failure ex -> fail ("Failed to match hyp: " ^ (string_of_match_exception ex)) | Success bindings -> let ms_hyps = (name, h) :: part_sol.ms_hyps in body ({ part_sol with ms_vars = bindings; ms_hyps = ms_hyps })) (fun () -> solve_mp_for_single_hyp name pat hs body part_sol) (** Scan ``hypotheses`` for matches for ``mp_hyps`` that lets ``body`` succeed. **) let rec solve_mp_for_hyps #a (mp_hyps: list (varname * pattern)) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (partial_solution: matching_solution) : Tac a = match mp_hyps with | [] -> body partial_solution | (name, pat) :: pats -> solve_mp_for_single_hyp name pat hypotheses (solve_mp_for_hyps pats hypotheses body) partial_solution (** Solve a matching problem. The solution returned is constructed to ensure that the continuation ``body`` succeeds: this implements the usual backtracking-match semantics. **) let solve_mp #a (problem: matching_problem) (hypotheses: list hypothesis) (goal: term) (body: matching_solution -> Tac a) : Tac a = let goal_ps = match problem.mp_goal with | None -> { ms_vars = []; ms_hyps = [] } | Some pat -> match interp_pattern pat goal with | Failure ex -> fail ("Failed to match goal: " ^ (string_of_match_exception ex)) | Success bindings -> { ms_vars = bindings; ms_hyps = [] } in solve_mp_for_hyps #a problem.mp_hyps hypotheses body goal_ps /// A DSL for pattern-matching /// ========================== /// /// Using pattern-matching problems as defined above is relatively cumbersome, /// so we now introduce a lightweight notation, in two steps: pattern notations, /// and matching-problem notations. /// /// Pattern notations /// ----------------- /// /// The first part of our pattern-matching syntax is pattern notations: we /// provide a reflective function which constructs a pattern from a term: /// variables are holes, free variables are constants, and applications are /// application patterns. (* FIXME: MOVE *) let name_of_namedv (x:namedv) : Tac string = unseal (inspect_namedv x).ppname (** Compile a term `tm` into a pattern. **) let rec pattern_of_term_ex tm : Tac (match_res pattern) = match inspect tm with | Tv_Var bv -> return (PVar (name_of_namedv bv)) | Tv_FVar fv | Tv_UInst fv _ -> let qn = fv_to_string fv in return (PQn qn) | Tv_Type _ -> return PType | Tv_App f (x, _) -> let? fpat = pattern_of_term_ex f in let? xpat = pattern_of_term_ex x in return (PApp fpat xpat) | _ -> raise (UnsupportedTermInPattern tm) (** β-reduce a term `tm`. This is useful to remove needles function applications introduced by F*, like ``(fun a b c -> a) 1 2 3``. **) let beta_reduce (tm: term) : Tac term = norm_term [] tm (** Compile a term `tm` into a pattern. **) let pattern_of_term tm : Tac pattern = match pattern_of_term_ex tm with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Problem notations /// ----------------- /// /// We then introduce a DSL for matching problems, best explained on the /// following example:: /// /// (fun (a b c: ①) (h1 h2 h3: hyp ②) (g: pm_goal ③) → ④) /// /// This notation is intended to express a pattern-matching problems with three /// holes ``a``, ``b``, and ``c`` of type ①, matching hypotheses ``h1``, ``h2``, /// and ``h3`` against pattern ② and the goal against the pattern ③. The body /// of the notation (④) is then run with appropriate terms bound to ``a``, /// ``b``, and ``c``, appropriate binders bound to ``h1``, ``h2``, and ``h3``, /// and ``()`` bound to ``g``. /// /// We call these patterns ``abspat``s (abstraction patterns), and we provide /// facilities to parse them into matching problems, and to run their bodies /// against a particular matching solution. // We used to annotate variables with an explicit 'var' marker, but then that // var annotation leaked into the types of other hypotheses due to type // inference, requiring non-trivial normalization. // let var (a: Type) = a let hyp (a: Type) = binding let pm_goal (a: Type) = unit let hyp_qn = `%hyp let goal_qn = `%pm_goal noeq type abspat_binder_kind = | ABKVar of typ | ABKHyp | ABKGoal let string_of_abspat_binder_kind = function | ABKVar _ -> "varname" | ABKHyp -> "hyp" | ABKGoal -> "goal" noeq type abspat_argspec = { asa_name: absvar; asa_kind: abspat_binder_kind } // We must store this continuation, because recomputing it yields different // names when the binders are re-opened. type abspat_continuation = list abspat_argspec * term

nb: FStar.Tactics.NamedView.binder -> FStar.Tactics.NamedView.term

Prims.Tot

let type_of_named_binder (nb: binder) : term =

nb.sort

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.beta_reduce

val beta_reduce (tm: term) : Tac term

val beta_reduce (tm: term) : Tac term

let beta_reduce (tm: term) : Tac term = norm_term [] tm

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp" let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)" /// The exception monad /// ------------------- noeq type match_res a = | Success of a | Failure of match_exception let return #a (x: a) : match_res a = Success x let (let?) (#a #b: Type) (f: match_res a) (g: a -> Tac (match_res b)) : Tac (match_res b) = match f with | Success aa -> g aa | Failure ex -> Failure ex let raise #a (ex: match_exception) : match_res a = Failure ex /// Liftings /// -------- /// /// There's a natural lifting from the exception monad into the tactic effect: let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern interpretation /// ====================== /// /// This section implement pattern-matching. This is strictly a one term, one /// pattern implementation — handling cases in which mutliple hypotheses match /// the same pattern is done later. type bindings = list (varname * term) let string_of_bindings (bindings: bindings) = String.concat "\n" (map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm)) bindings) (** Match a pattern against a term. `cur_bindings` is a list of bindings collected while matching previous parts of the pattern. Returns a result in the exception monad. **) let rec interp_pattern_aux (pat: pattern) (cur_bindings: bindings) (tm:term) : Tac (match_res bindings) = let interp_var (v: varname) cur_bindings tm = match List.Tot.Base.assoc v cur_bindings with | Some tm' -> if term_eq tm tm' then return cur_bindings else raise (NonLinearMismatch (v, tm, tm')) | None -> return ((v, tm) :: cur_bindings) in let interp_qn (qn: qn) cur_bindings tm = match inspect tm with | Tv_UInst fv _ | Tv_FVar fv -> if fv_to_string fv = qn then return cur_bindings else raise (NameMismatch (qn, (fv_to_string fv))) | _ -> raise (SimpleMismatch (pat, tm)) in let interp_type cur_bindings tm = match inspect tm with | Tv_Type _ -> return cur_bindings | _ -> raise (SimpleMismatch (pat, tm)) in let interp_app (p_hd p_arg: (p:pattern{p << pat})) cur_bindings tm = match inspect tm with | Tv_App hd (arg, _) -> let? with_hd = interp_pattern_aux p_hd cur_bindings hd in let? with_arg = interp_pattern_aux p_arg with_hd arg in return with_arg | _ -> raise (SimpleMismatch (pat, tm)) in match pat with | PVar var -> interp_var var cur_bindings tm | PQn qn -> interp_qn qn cur_bindings tm | PType -> interp_type cur_bindings tm | PApp p_hd p_arg -> interp_app p_hd p_arg cur_bindings tm (** Match a pattern `pat` against a term. Returns a result in the exception monad. **) let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) = fun (tm: term) -> let? rev_bindings = interp_pattern_aux pat [] tm in return (List.Tot.Base.rev rev_bindings) (** Match a term `tm` against a pattern `pat`. Raises an exception if the match fails. This is mostly useful for debugging: use ``mgw`` to capture matches. **) let match_term pat (tm : term) : Tac bindings = match interp_pattern pat (norm_term [] tm) with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern-matching problems /// ========================= /// /// Generalizing past single-term single-pattern problems, we obtain the /// following notions of pattern-matching problems and solutions: let debug msg : Tac unit = () // print msg /// Definitions /// ----------- let absvar = binding type hypothesis = binding /// A matching problem is composed of holes (``mp_vars``), hypothesis patterns /// (``mp_hyps``), and a goal pattern (``mp_goal``). noeq type matching_problem = { mp_vars: list varname; mp_hyps: list (varname * pattern); mp_goal: option pattern } let string_of_matching_problem mp = let vars = String.concat ", " mp.mp_vars in let hyps = String.concat "\n " (List.Tot.Base.map (fun (nm, pat) -> nm ^ ": " ^ (string_of_pattern pat)) mp.mp_hyps) in let goal = match mp.mp_goal with | None -> "_" | Some pat -> string_of_pattern pat in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ "\n" ^ " goal: " ^ goal ^ " }" /// A solution is composed of terms captured to mach the holes, and binders /// captured to match hypothesis patterns. noeq type matching_solution = { ms_vars: list (varname * term); ms_hyps: list (varname * hypothesis) } let string_of_matching_solution ms = let vars = String.concat "\n " (map (fun (varname, tm) -> varname ^ ": " ^ (term_to_string tm)) ms.ms_vars) in let hyps = String.concat "\n " (map (fun (nm, binding) -> nm ^ ": " ^ (binding_to_string binding)) ms.ms_hyps) in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ " }" (** Find a varname in an association list; fail if it can't be found. **) let assoc_varname_fail (#b: Type) (key: varname) (ls: list (varname * b)) : Tac b = match List.Tot.Base.assoc key ls with | None -> fail ("Not found: " ^ key) | Some x -> x let ms_locate_hyp (a: Type) (solution: matching_solution) (name: varname) : Tac hypothesis = assoc_varname_fail name solution.ms_hyps let ms_locate_var (a: Type) (solution: matching_solution) (name: varname) : Tac a = unquote #a (assoc_varname_fail name solution.ms_vars) let ms_locate_unit (a: Type) _solution _binder_name : Tac unit = () /// Resolution /// ---------- /// /// Solving a matching problem is a two-steps process: find an initial /// assignment for holes based on the goal pattern, then find a set of /// hypotheses matching hypothesis patterns. /// /// Note that the implementation takes a continuation of type /// ``matching_solution -> Tac a``. This continuation is needed because we want /// users to be able to provide extra criteria on matching solutions (most /// commonly, this criterion is that a particular tactic should run /// successfuly). /// /// This makes it easy to implement a simple for of search through the context, /// where one can find a hypothesis matching a particular predicate by /// constructing a trivial matching problem and passing the predicate as the /// continuation. (** Scan ``hypotheses`` for a match for ``pat`` that lets ``body`` succeed. ``name`` is used to refer to the hypothesis matched in the final solution. ``part_sol`` includes bindings gathered while matching previous solutions. **) let rec solve_mp_for_single_hyp #a (name: varname) (pat: pattern) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (part_sol: matching_solution) : Tac a = match hypotheses with | [] -> fail #a "No matching hypothesis" | h :: hs -> or_else // Must be in ``Tac`` here to run `body` (fun () -> match interp_pattern_aux pat part_sol.ms_vars (type_of_binding h) with | Failure ex -> fail ("Failed to match hyp: " ^ (string_of_match_exception ex)) | Success bindings -> let ms_hyps = (name, h) :: part_sol.ms_hyps in body ({ part_sol with ms_vars = bindings; ms_hyps = ms_hyps })) (fun () -> solve_mp_for_single_hyp name pat hs body part_sol) (** Scan ``hypotheses`` for matches for ``mp_hyps`` that lets ``body`` succeed. **) let rec solve_mp_for_hyps #a (mp_hyps: list (varname * pattern)) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (partial_solution: matching_solution) : Tac a = match mp_hyps with | [] -> body partial_solution | (name, pat) :: pats -> solve_mp_for_single_hyp name pat hypotheses (solve_mp_for_hyps pats hypotheses body) partial_solution (** Solve a matching problem. The solution returned is constructed to ensure that the continuation ``body`` succeeds: this implements the usual backtracking-match semantics. **) let solve_mp #a (problem: matching_problem) (hypotheses: list hypothesis) (goal: term) (body: matching_solution -> Tac a) : Tac a = let goal_ps = match problem.mp_goal with | None -> { ms_vars = []; ms_hyps = [] } | Some pat -> match interp_pattern pat goal with | Failure ex -> fail ("Failed to match goal: " ^ (string_of_match_exception ex)) | Success bindings -> { ms_vars = bindings; ms_hyps = [] } in solve_mp_for_hyps #a problem.mp_hyps hypotheses body goal_ps /// A DSL for pattern-matching /// ========================== /// /// Using pattern-matching problems as defined above is relatively cumbersome, /// so we now introduce a lightweight notation, in two steps: pattern notations, /// and matching-problem notations. /// /// Pattern notations /// ----------------- /// /// The first part of our pattern-matching syntax is pattern notations: we /// provide a reflective function which constructs a pattern from a term: /// variables are holes, free variables are constants, and applications are /// application patterns. (* FIXME: MOVE *) let name_of_namedv (x:namedv) : Tac string = unseal (inspect_namedv x).ppname (** Compile a term `tm` into a pattern. **) let rec pattern_of_term_ex tm : Tac (match_res pattern) = match inspect tm with | Tv_Var bv -> return (PVar (name_of_namedv bv)) | Tv_FVar fv | Tv_UInst fv _ -> let qn = fv_to_string fv in return (PQn qn) | Tv_Type _ -> return PType | Tv_App f (x, _) -> let? fpat = pattern_of_term_ex f in let? xpat = pattern_of_term_ex x in return (PApp fpat xpat) | _ -> raise (UnsupportedTermInPattern tm) (** β-reduce a term `tm`. This is useful to remove needles function applications introduced by F*, like

tm: FStar.Tactics.NamedView.term -> FStar.Tactics.Effect.Tac FStar.Tactics.NamedView.term

FStar.Tactics.Effect.Tac

let beta_reduce (tm: term) : Tac term =

norm_term [] tm

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.cleanup_abspat

val cleanup_abspat (t: term) : Tac term

val cleanup_abspat (t: term) : Tac term

let cleanup_abspat (t: term) : Tac term = norm_term [] t

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp" let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)" /// The exception monad /// ------------------- noeq type match_res a = | Success of a | Failure of match_exception let return #a (x: a) : match_res a = Success x let (let?) (#a #b: Type) (f: match_res a) (g: a -> Tac (match_res b)) : Tac (match_res b) = match f with | Success aa -> g aa | Failure ex -> Failure ex let raise #a (ex: match_exception) : match_res a = Failure ex /// Liftings /// -------- /// /// There's a natural lifting from the exception monad into the tactic effect: let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern interpretation /// ====================== /// /// This section implement pattern-matching. This is strictly a one term, one /// pattern implementation — handling cases in which mutliple hypotheses match /// the same pattern is done later. type bindings = list (varname * term) let string_of_bindings (bindings: bindings) = String.concat "\n" (map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm)) bindings) (** Match a pattern against a term. `cur_bindings` is a list of bindings collected while matching previous parts of the pattern. Returns a result in the exception monad. **) let rec interp_pattern_aux (pat: pattern) (cur_bindings: bindings) (tm:term) : Tac (match_res bindings) = let interp_var (v: varname) cur_bindings tm = match List.Tot.Base.assoc v cur_bindings with | Some tm' -> if term_eq tm tm' then return cur_bindings else raise (NonLinearMismatch (v, tm, tm')) | None -> return ((v, tm) :: cur_bindings) in let interp_qn (qn: qn) cur_bindings tm = match inspect tm with | Tv_UInst fv _ | Tv_FVar fv -> if fv_to_string fv = qn then return cur_bindings else raise (NameMismatch (qn, (fv_to_string fv))) | _ -> raise (SimpleMismatch (pat, tm)) in let interp_type cur_bindings tm = match inspect tm with | Tv_Type _ -> return cur_bindings | _ -> raise (SimpleMismatch (pat, tm)) in let interp_app (p_hd p_arg: (p:pattern{p << pat})) cur_bindings tm = match inspect tm with | Tv_App hd (arg, _) -> let? with_hd = interp_pattern_aux p_hd cur_bindings hd in let? with_arg = interp_pattern_aux p_arg with_hd arg in return with_arg | _ -> raise (SimpleMismatch (pat, tm)) in match pat with | PVar var -> interp_var var cur_bindings tm | PQn qn -> interp_qn qn cur_bindings tm | PType -> interp_type cur_bindings tm | PApp p_hd p_arg -> interp_app p_hd p_arg cur_bindings tm (** Match a pattern `pat` against a term. Returns a result in the exception monad. **) let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) = fun (tm: term) -> let? rev_bindings = interp_pattern_aux pat [] tm in return (List.Tot.Base.rev rev_bindings) (** Match a term `tm` against a pattern `pat`. Raises an exception if the match fails. This is mostly useful for debugging: use ``mgw`` to capture matches. **) let match_term pat (tm : term) : Tac bindings = match interp_pattern pat (norm_term [] tm) with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern-matching problems /// ========================= /// /// Generalizing past single-term single-pattern problems, we obtain the /// following notions of pattern-matching problems and solutions: let debug msg : Tac unit = () // print msg /// Definitions /// ----------- let absvar = binding type hypothesis = binding /// A matching problem is composed of holes (``mp_vars``), hypothesis patterns /// (``mp_hyps``), and a goal pattern (``mp_goal``). noeq type matching_problem = { mp_vars: list varname; mp_hyps: list (varname * pattern); mp_goal: option pattern } let string_of_matching_problem mp = let vars = String.concat ", " mp.mp_vars in let hyps = String.concat "\n " (List.Tot.Base.map (fun (nm, pat) -> nm ^ ": " ^ (string_of_pattern pat)) mp.mp_hyps) in let goal = match mp.mp_goal with | None -> "_" | Some pat -> string_of_pattern pat in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ "\n" ^ " goal: " ^ goal ^ " }" /// A solution is composed of terms captured to mach the holes, and binders /// captured to match hypothesis patterns. noeq type matching_solution = { ms_vars: list (varname * term); ms_hyps: list (varname * hypothesis) } let string_of_matching_solution ms = let vars = String.concat "\n " (map (fun (varname, tm) -> varname ^ ": " ^ (term_to_string tm)) ms.ms_vars) in let hyps = String.concat "\n " (map (fun (nm, binding) -> nm ^ ": " ^ (binding_to_string binding)) ms.ms_hyps) in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ " }" (** Find a varname in an association list; fail if it can't be found. **) let assoc_varname_fail (#b: Type) (key: varname) (ls: list (varname * b)) : Tac b = match List.Tot.Base.assoc key ls with | None -> fail ("Not found: " ^ key) | Some x -> x let ms_locate_hyp (a: Type) (solution: matching_solution) (name: varname) : Tac hypothesis = assoc_varname_fail name solution.ms_hyps let ms_locate_var (a: Type) (solution: matching_solution) (name: varname) : Tac a = unquote #a (assoc_varname_fail name solution.ms_vars) let ms_locate_unit (a: Type) _solution _binder_name : Tac unit = () /// Resolution /// ---------- /// /// Solving a matching problem is a two-steps process: find an initial /// assignment for holes based on the goal pattern, then find a set of /// hypotheses matching hypothesis patterns. /// /// Note that the implementation takes a continuation of type /// ``matching_solution -> Tac a``. This continuation is needed because we want /// users to be able to provide extra criteria on matching solutions (most /// commonly, this criterion is that a particular tactic should run /// successfuly). /// /// This makes it easy to implement a simple for of search through the context, /// where one can find a hypothesis matching a particular predicate by /// constructing a trivial matching problem and passing the predicate as the /// continuation. (** Scan ``hypotheses`` for a match for ``pat`` that lets ``body`` succeed. ``name`` is used to refer to the hypothesis matched in the final solution. ``part_sol`` includes bindings gathered while matching previous solutions. **) let rec solve_mp_for_single_hyp #a (name: varname) (pat: pattern) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (part_sol: matching_solution) : Tac a = match hypotheses with | [] -> fail #a "No matching hypothesis" | h :: hs -> or_else // Must be in ``Tac`` here to run `body` (fun () -> match interp_pattern_aux pat part_sol.ms_vars (type_of_binding h) with | Failure ex -> fail ("Failed to match hyp: " ^ (string_of_match_exception ex)) | Success bindings -> let ms_hyps = (name, h) :: part_sol.ms_hyps in body ({ part_sol with ms_vars = bindings; ms_hyps = ms_hyps })) (fun () -> solve_mp_for_single_hyp name pat hs body part_sol) (** Scan ``hypotheses`` for matches for ``mp_hyps`` that lets ``body`` succeed. **) let rec solve_mp_for_hyps #a (mp_hyps: list (varname * pattern)) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (partial_solution: matching_solution) : Tac a = match mp_hyps with | [] -> body partial_solution | (name, pat) :: pats -> solve_mp_for_single_hyp name pat hypotheses (solve_mp_for_hyps pats hypotheses body) partial_solution (** Solve a matching problem. The solution returned is constructed to ensure that the continuation ``body`` succeeds: this implements the usual backtracking-match semantics. **) let solve_mp #a (problem: matching_problem) (hypotheses: list hypothesis) (goal: term) (body: matching_solution -> Tac a) : Tac a = let goal_ps = match problem.mp_goal with | None -> { ms_vars = []; ms_hyps = [] } | Some pat -> match interp_pattern pat goal with | Failure ex -> fail ("Failed to match goal: " ^ (string_of_match_exception ex)) | Success bindings -> { ms_vars = bindings; ms_hyps = [] } in solve_mp_for_hyps #a problem.mp_hyps hypotheses body goal_ps /// A DSL for pattern-matching /// ========================== /// /// Using pattern-matching problems as defined above is relatively cumbersome, /// so we now introduce a lightweight notation, in two steps: pattern notations, /// and matching-problem notations. /// /// Pattern notations /// ----------------- /// /// The first part of our pattern-matching syntax is pattern notations: we /// provide a reflective function which constructs a pattern from a term: /// variables are holes, free variables are constants, and applications are /// application patterns. (* FIXME: MOVE *) let name_of_namedv (x:namedv) : Tac string = unseal (inspect_namedv x).ppname (** Compile a term `tm` into a pattern. **) let rec pattern_of_term_ex tm : Tac (match_res pattern) = match inspect tm with | Tv_Var bv -> return (PVar (name_of_namedv bv)) | Tv_FVar fv | Tv_UInst fv _ -> let qn = fv_to_string fv in return (PQn qn) | Tv_Type _ -> return PType | Tv_App f (x, _) -> let? fpat = pattern_of_term_ex f in let? xpat = pattern_of_term_ex x in return (PApp fpat xpat) | _ -> raise (UnsupportedTermInPattern tm) (** β-reduce a term `tm`. This is useful to remove needles function applications introduced by F*, like ``(fun a b c -> a) 1 2 3``. **) let beta_reduce (tm: term) : Tac term = norm_term [] tm (** Compile a term `tm` into a pattern. **) let pattern_of_term tm : Tac pattern = match pattern_of_term_ex tm with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Problem notations /// ----------------- /// /// We then introduce a DSL for matching problems, best explained on the /// following example:: /// /// (fun (a b c: ①) (h1 h2 h3: hyp ②) (g: pm_goal ③) → ④) /// /// This notation is intended to express a pattern-matching problems with three /// holes ``a``, ``b``, and ``c`` of type ①, matching hypotheses ``h1``, ``h2``, /// and ``h3`` against pattern ② and the goal against the pattern ③. The body /// of the notation (④) is then run with appropriate terms bound to ``a``, /// ``b``, and ``c``, appropriate binders bound to ``h1``, ``h2``, and ``h3``, /// and ``()`` bound to ``g``. /// /// We call these patterns ``abspat``s (abstraction patterns), and we provide /// facilities to parse them into matching problems, and to run their bodies /// against a particular matching solution. // We used to annotate variables with an explicit 'var' marker, but then that // var annotation leaked into the types of other hypotheses due to type // inference, requiring non-trivial normalization. // let var (a: Type) = a let hyp (a: Type) = binding let pm_goal (a: Type) = unit let hyp_qn = `%hyp let goal_qn = `%pm_goal noeq type abspat_binder_kind = | ABKVar of typ | ABKHyp | ABKGoal let string_of_abspat_binder_kind = function | ABKVar _ -> "varname" | ABKHyp -> "hyp" | ABKGoal -> "goal" noeq type abspat_argspec = { asa_name: absvar; asa_kind: abspat_binder_kind } // We must store this continuation, because recomputing it yields different // names when the binders are re-opened. type abspat_continuation = list abspat_argspec * term let type_of_named_binder (nb : binder) : term = nb.sort let classify_abspat_binder (b : binder): Tac (abspat_binder_kind * term) = let varname = "v" in let hyp_pat = PApp (PQn hyp_qn) (PVar varname) in let goal_pat = PApp (PQn goal_qn) (PVar varname) in let typ = type_of_named_binder b in match interp_pattern hyp_pat typ with | Success [(_, hyp_typ)] -> ABKHyp, hyp_typ | Success _ -> fail "classifiy_abspat_binder: impossible (1)" | Failure _ -> match interp_pattern goal_pat typ with | Success [(_, goal_typ)] -> ABKGoal, goal_typ | Success _ -> fail "classifiy_abspat_binder: impossible (2)" | Failure _ -> ABKVar typ, typ (** Split an abstraction `tm` into a list of binders and a body. **) let rec binders_and_body_of_abs tm : Tac (list binder * term) = match inspect tm with | Tv_Abs binder tm -> let binders, body = binders_and_body_of_abs tm in binder :: binders, body | _ -> [], tm

t: FStar.Tactics.NamedView.term -> FStar.Tactics.Effect.Tac FStar.Tactics.NamedView.term

FStar.Tactics.Effect.Tac

let cleanup_abspat (t: term) : Tac term =

norm_term [] t

Hacl.Spec.SHA2.Lemmas.fst

Hacl.Spec.SHA2.Lemmas.transpose_ws4_lemma_ij

val transpose_ws4_lemma_ij: #a:sha2_alg -> #m:m_spec{lanes a m == 4} // lanes a m * lanes a m = 16 -> ws:ws_spec a m -> j:nat{j < lanes a m} -> i:nat{i < 16} -> Lemma (let l = lanes a m in (vec_v (transpose_ws4 ws).[i]).[j] == (vec_v ws.[i / l * l + j]).[i % l])

val transpose_ws4_lemma_ij: #a:sha2_alg -> #m:m_spec{lanes a m == 4} // lanes a m * lanes a m = 16 -> ws:ws_spec a m -> j:nat{j < lanes a m} -> i:nat{i < 16} -> Lemma (let l = lanes a m in (vec_v (transpose_ws4 ws).[i]).[j] == (vec_v ws.[i / l * l + j]).[i % l])

let transpose_ws4_lemma_ij #a #m ws j i = let l = lanes a m in let i_sub = i / l in let j_sub = i % l in assert (i_sub * l + j_sub == i); let vs = sub ws (i_sub * l) l in eq_intro (sub (transpose_ws4 ws) (i_sub * l) l) (transpose4x4_lseq vs); //assert ((transpose_ws4 ws).[i] == (sub (transpose_ws4 ws) (i_sub * l) l).[j_sub]); //assert ((transpose_ws4 ws).[i] == (transpose4x4_lseq vs).[j_sub]); assert ((vec_v (transpose_ws4 ws).[i]).[j] == (vec_v (transpose4x4_lseq vs).[j_sub]).[j]); transpose4x4_lemma vs; assert ((vec_v (transpose_ws4 ws).[i]).[j] == (vec_v vs.[j]).[j_sub]); assert ((vec_v (transpose_ws4 ws).[i]).[j] == (vec_v ws.[i_sub * l + j]).[j_sub])

module Hacl.Spec.SHA2.Lemmas open FStar.Mul open Lib.IntTypes open Lib.Sequence open Lib.IntVector open Lib.IntVector.Transpose open Spec.Hash.Definitions open Hacl.Spec.SHA2.Vec #set-options "--z3rlimit 50 --fuel 0 --ifuel 1" val transpose_ws4_lemma_ij: #a:sha2_alg -> #m:m_spec{lanes a m == 4} // lanes a m * lanes a m = 16 -> ws:ws_spec a m -> j:nat{j < lanes a m} -> i:nat{i < 16} -> Lemma (let l = lanes a m in (vec_v (transpose_ws4 ws).[i]).[j] == (vec_v ws.[i / l * l + j]).[i % l])

ws: Hacl.Spec.SHA2.Vec.ws_spec a m -> j: Prims.nat{j < Hacl.Spec.SHA2.Vec.lanes a m} -> i: Prims.nat{i < 16} -> FStar.Pervasives.Lemma (ensures (let l = Hacl.Spec.SHA2.Vec.lanes a m in (Lib.IntVector.vec_v (Hacl.Spec.SHA2.Vec.transpose_ws4 ws).[ i ]).[ j ] == (Lib.IntVector.vec_v ws.[ (i / l) * l + j ]).[ i % l ]))

FStar.Pervasives.Lemma

let transpose_ws4_lemma_ij #a #m ws j i =

let l = lanes a m in let i_sub = i / l in let j_sub = i % l in assert (i_sub * l + j_sub == i); let vs = sub ws (i_sub * l) l in eq_intro (sub (transpose_ws4 ws) (i_sub * l) l) (transpose4x4_lseq vs); assert ((vec_v (transpose_ws4 ws).[ i ]).[ j ] == (vec_v (transpose4x4_lseq vs).[ j_sub ]).[ j ]); transpose4x4_lemma vs; assert ((vec_v (transpose_ws4 ws).[ i ]).[ j ] == (vec_v vs.[ j ]).[ j_sub ]); assert ((vec_v (transpose_ws4 ws).[ i ]).[ j ] == (vec_v ws.[ i_sub * l + j ]).[ j_sub ])

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.name_of_named_binder

val name_of_named_binder (nb: binder) : Tac string

val name_of_named_binder (nb: binder) : Tac string

let name_of_named_binder (nb : binder) : Tac string = unseal nb.ppname

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp" let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)" /// The exception monad /// ------------------- noeq type match_res a = | Success of a | Failure of match_exception let return #a (x: a) : match_res a = Success x let (let?) (#a #b: Type) (f: match_res a) (g: a -> Tac (match_res b)) : Tac (match_res b) = match f with | Success aa -> g aa | Failure ex -> Failure ex let raise #a (ex: match_exception) : match_res a = Failure ex /// Liftings /// -------- /// /// There's a natural lifting from the exception monad into the tactic effect: let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern interpretation /// ====================== /// /// This section implement pattern-matching. This is strictly a one term, one /// pattern implementation — handling cases in which mutliple hypotheses match /// the same pattern is done later. type bindings = list (varname * term) let string_of_bindings (bindings: bindings) = String.concat "\n" (map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm)) bindings) (** Match a pattern against a term. `cur_bindings` is a list of bindings collected while matching previous parts of the pattern. Returns a result in the exception monad. **) let rec interp_pattern_aux (pat: pattern) (cur_bindings: bindings) (tm:term) : Tac (match_res bindings) = let interp_var (v: varname) cur_bindings tm = match List.Tot.Base.assoc v cur_bindings with | Some tm' -> if term_eq tm tm' then return cur_bindings else raise (NonLinearMismatch (v, tm, tm')) | None -> return ((v, tm) :: cur_bindings) in let interp_qn (qn: qn) cur_bindings tm = match inspect tm with | Tv_UInst fv _ | Tv_FVar fv -> if fv_to_string fv = qn then return cur_bindings else raise (NameMismatch (qn, (fv_to_string fv))) | _ -> raise (SimpleMismatch (pat, tm)) in let interp_type cur_bindings tm = match inspect tm with | Tv_Type _ -> return cur_bindings | _ -> raise (SimpleMismatch (pat, tm)) in let interp_app (p_hd p_arg: (p:pattern{p << pat})) cur_bindings tm = match inspect tm with | Tv_App hd (arg, _) -> let? with_hd = interp_pattern_aux p_hd cur_bindings hd in let? with_arg = interp_pattern_aux p_arg with_hd arg in return with_arg | _ -> raise (SimpleMismatch (pat, tm)) in match pat with | PVar var -> interp_var var cur_bindings tm | PQn qn -> interp_qn qn cur_bindings tm | PType -> interp_type cur_bindings tm | PApp p_hd p_arg -> interp_app p_hd p_arg cur_bindings tm (** Match a pattern `pat` against a term. Returns a result in the exception monad. **) let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) = fun (tm: term) -> let? rev_bindings = interp_pattern_aux pat [] tm in return (List.Tot.Base.rev rev_bindings) (** Match a term `tm` against a pattern `pat`. Raises an exception if the match fails. This is mostly useful for debugging: use ``mgw`` to capture matches. **) let match_term pat (tm : term) : Tac bindings = match interp_pattern pat (norm_term [] tm) with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern-matching problems /// ========================= /// /// Generalizing past single-term single-pattern problems, we obtain the /// following notions of pattern-matching problems and solutions: let debug msg : Tac unit = () // print msg /// Definitions /// ----------- let absvar = binding type hypothesis = binding /// A matching problem is composed of holes (``mp_vars``), hypothesis patterns /// (``mp_hyps``), and a goal pattern (``mp_goal``). noeq type matching_problem = { mp_vars: list varname; mp_hyps: list (varname * pattern); mp_goal: option pattern } let string_of_matching_problem mp = let vars = String.concat ", " mp.mp_vars in let hyps = String.concat "\n " (List.Tot.Base.map (fun (nm, pat) -> nm ^ ": " ^ (string_of_pattern pat)) mp.mp_hyps) in let goal = match mp.mp_goal with | None -> "_" | Some pat -> string_of_pattern pat in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ "\n" ^ " goal: " ^ goal ^ " }" /// A solution is composed of terms captured to mach the holes, and binders /// captured to match hypothesis patterns. noeq type matching_solution = { ms_vars: list (varname * term); ms_hyps: list (varname * hypothesis) } let string_of_matching_solution ms = let vars = String.concat "\n " (map (fun (varname, tm) -> varname ^ ": " ^ (term_to_string tm)) ms.ms_vars) in let hyps = String.concat "\n " (map (fun (nm, binding) -> nm ^ ": " ^ (binding_to_string binding)) ms.ms_hyps) in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ " }" (** Find a varname in an association list; fail if it can't be found. **) let assoc_varname_fail (#b: Type) (key: varname) (ls: list (varname * b)) : Tac b = match List.Tot.Base.assoc key ls with | None -> fail ("Not found: " ^ key) | Some x -> x let ms_locate_hyp (a: Type) (solution: matching_solution) (name: varname) : Tac hypothesis = assoc_varname_fail name solution.ms_hyps let ms_locate_var (a: Type) (solution: matching_solution) (name: varname) : Tac a = unquote #a (assoc_varname_fail name solution.ms_vars) let ms_locate_unit (a: Type) _solution _binder_name : Tac unit = () /// Resolution /// ---------- /// /// Solving a matching problem is a two-steps process: find an initial /// assignment for holes based on the goal pattern, then find a set of /// hypotheses matching hypothesis patterns. /// /// Note that the implementation takes a continuation of type /// ``matching_solution -> Tac a``. This continuation is needed because we want /// users to be able to provide extra criteria on matching solutions (most /// commonly, this criterion is that a particular tactic should run /// successfuly). /// /// This makes it easy to implement a simple for of search through the context, /// where one can find a hypothesis matching a particular predicate by /// constructing a trivial matching problem and passing the predicate as the /// continuation. (** Scan ``hypotheses`` for a match for ``pat`` that lets ``body`` succeed. ``name`` is used to refer to the hypothesis matched in the final solution. ``part_sol`` includes bindings gathered while matching previous solutions. **) let rec solve_mp_for_single_hyp #a (name: varname) (pat: pattern) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (part_sol: matching_solution) : Tac a = match hypotheses with | [] -> fail #a "No matching hypothesis" | h :: hs -> or_else // Must be in ``Tac`` here to run `body` (fun () -> match interp_pattern_aux pat part_sol.ms_vars (type_of_binding h) with | Failure ex -> fail ("Failed to match hyp: " ^ (string_of_match_exception ex)) | Success bindings -> let ms_hyps = (name, h) :: part_sol.ms_hyps in body ({ part_sol with ms_vars = bindings; ms_hyps = ms_hyps })) (fun () -> solve_mp_for_single_hyp name pat hs body part_sol) (** Scan ``hypotheses`` for matches for ``mp_hyps`` that lets ``body`` succeed. **) let rec solve_mp_for_hyps #a (mp_hyps: list (varname * pattern)) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (partial_solution: matching_solution) : Tac a = match mp_hyps with | [] -> body partial_solution | (name, pat) :: pats -> solve_mp_for_single_hyp name pat hypotheses (solve_mp_for_hyps pats hypotheses body) partial_solution (** Solve a matching problem. The solution returned is constructed to ensure that the continuation ``body`` succeeds: this implements the usual backtracking-match semantics. **) let solve_mp #a (problem: matching_problem) (hypotheses: list hypothesis) (goal: term) (body: matching_solution -> Tac a) : Tac a = let goal_ps = match problem.mp_goal with | None -> { ms_vars = []; ms_hyps = [] } | Some pat -> match interp_pattern pat goal with | Failure ex -> fail ("Failed to match goal: " ^ (string_of_match_exception ex)) | Success bindings -> { ms_vars = bindings; ms_hyps = [] } in solve_mp_for_hyps #a problem.mp_hyps hypotheses body goal_ps /// A DSL for pattern-matching /// ========================== /// /// Using pattern-matching problems as defined above is relatively cumbersome, /// so we now introduce a lightweight notation, in two steps: pattern notations, /// and matching-problem notations. /// /// Pattern notations /// ----------------- /// /// The first part of our pattern-matching syntax is pattern notations: we /// provide a reflective function which constructs a pattern from a term: /// variables are holes, free variables are constants, and applications are /// application patterns. (* FIXME: MOVE *) let name_of_namedv (x:namedv) : Tac string = unseal (inspect_namedv x).ppname (** Compile a term `tm` into a pattern. **) let rec pattern_of_term_ex tm : Tac (match_res pattern) = match inspect tm with | Tv_Var bv -> return (PVar (name_of_namedv bv)) | Tv_FVar fv | Tv_UInst fv _ -> let qn = fv_to_string fv in return (PQn qn) | Tv_Type _ -> return PType | Tv_App f (x, _) -> let? fpat = pattern_of_term_ex f in let? xpat = pattern_of_term_ex x in return (PApp fpat xpat) | _ -> raise (UnsupportedTermInPattern tm) (** β-reduce a term `tm`. This is useful to remove needles function applications introduced by F*, like ``(fun a b c -> a) 1 2 3``. **) let beta_reduce (tm: term) : Tac term = norm_term [] tm (** Compile a term `tm` into a pattern. **) let pattern_of_term tm : Tac pattern = match pattern_of_term_ex tm with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Problem notations /// ----------------- /// /// We then introduce a DSL for matching problems, best explained on the /// following example:: /// /// (fun (a b c: ①) (h1 h2 h3: hyp ②) (g: pm_goal ③) → ④) /// /// This notation is intended to express a pattern-matching problems with three /// holes ``a``, ``b``, and ``c`` of type ①, matching hypotheses ``h1``, ``h2``, /// and ``h3`` against pattern ② and the goal against the pattern ③. The body /// of the notation (④) is then run with appropriate terms bound to ``a``, /// ``b``, and ``c``, appropriate binders bound to ``h1``, ``h2``, and ``h3``, /// and ``()`` bound to ``g``. /// /// We call these patterns ``abspat``s (abstraction patterns), and we provide /// facilities to parse them into matching problems, and to run their bodies /// against a particular matching solution. // We used to annotate variables with an explicit 'var' marker, but then that // var annotation leaked into the types of other hypotheses due to type // inference, requiring non-trivial normalization. // let var (a: Type) = a let hyp (a: Type) = binding let pm_goal (a: Type) = unit let hyp_qn = `%hyp let goal_qn = `%pm_goal noeq type abspat_binder_kind = | ABKVar of typ | ABKHyp | ABKGoal let string_of_abspat_binder_kind = function | ABKVar _ -> "varname" | ABKHyp -> "hyp" | ABKGoal -> "goal" noeq type abspat_argspec = { asa_name: absvar; asa_kind: abspat_binder_kind } // We must store this continuation, because recomputing it yields different // names when the binders are re-opened. type abspat_continuation = list abspat_argspec * term let type_of_named_binder (nb : binder) : term = nb.sort let classify_abspat_binder (b : binder): Tac (abspat_binder_kind * term) = let varname = "v" in let hyp_pat = PApp (PQn hyp_qn) (PVar varname) in let goal_pat = PApp (PQn goal_qn) (PVar varname) in let typ = type_of_named_binder b in match interp_pattern hyp_pat typ with | Success [(_, hyp_typ)] -> ABKHyp, hyp_typ | Success _ -> fail "classifiy_abspat_binder: impossible (1)" | Failure _ -> match interp_pattern goal_pat typ with | Success [(_, goal_typ)] -> ABKGoal, goal_typ | Success _ -> fail "classifiy_abspat_binder: impossible (2)" | Failure _ -> ABKVar typ, typ (** Split an abstraction `tm` into a list of binders and a body. **) let rec binders_and_body_of_abs tm : Tac (list binder * term) = match inspect tm with | Tv_Abs binder tm -> let binders, body = binders_and_body_of_abs tm in binder :: binders, body | _ -> [], tm let cleanup_abspat (t: term) : Tac term = norm_term [] t

nb: FStar.Tactics.NamedView.binder -> FStar.Tactics.Effect.Tac Prims.string

FStar.Tactics.Effect.Tac

let name_of_named_binder (nb: binder) : Tac string =

unseal nb.ppname

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.specialize_abspat_continuation'

val specialize_abspat_continuation' (continuation: abspat_continuation) (solution_term: term) : Tac term

val specialize_abspat_continuation' (continuation: abspat_continuation) (solution_term: term) : Tac term

let specialize_abspat_continuation' (continuation: abspat_continuation) (solution_term:term) : Tac term = let mk_arg_term argspec = abspat_arg_of_abspat_argspec solution_term argspec in let argspecs, body = continuation in hoist_and_apply body (map mk_arg_term argspecs) []

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp" let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)" /// The exception monad /// ------------------- noeq type match_res a = | Success of a | Failure of match_exception let return #a (x: a) : match_res a = Success x let (let?) (#a #b: Type) (f: match_res a) (g: a -> Tac (match_res b)) : Tac (match_res b) = match f with | Success aa -> g aa | Failure ex -> Failure ex let raise #a (ex: match_exception) : match_res a = Failure ex /// Liftings /// -------- /// /// There's a natural lifting from the exception monad into the tactic effect: let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern interpretation /// ====================== /// /// This section implement pattern-matching. This is strictly a one term, one /// pattern implementation — handling cases in which mutliple hypotheses match /// the same pattern is done later. type bindings = list (varname * term) let string_of_bindings (bindings: bindings) = String.concat "\n" (map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm)) bindings) (** Match a pattern against a term. `cur_bindings` is a list of bindings collected while matching previous parts of the pattern. Returns a result in the exception monad. **) let rec interp_pattern_aux (pat: pattern) (cur_bindings: bindings) (tm:term) : Tac (match_res bindings) = let interp_var (v: varname) cur_bindings tm = match List.Tot.Base.assoc v cur_bindings with | Some tm' -> if term_eq tm tm' then return cur_bindings else raise (NonLinearMismatch (v, tm, tm')) | None -> return ((v, tm) :: cur_bindings) in let interp_qn (qn: qn) cur_bindings tm = match inspect tm with | Tv_UInst fv _ | Tv_FVar fv -> if fv_to_string fv = qn then return cur_bindings else raise (NameMismatch (qn, (fv_to_string fv))) | _ -> raise (SimpleMismatch (pat, tm)) in let interp_type cur_bindings tm = match inspect tm with | Tv_Type _ -> return cur_bindings | _ -> raise (SimpleMismatch (pat, tm)) in let interp_app (p_hd p_arg: (p:pattern{p << pat})) cur_bindings tm = match inspect tm with | Tv_App hd (arg, _) -> let? with_hd = interp_pattern_aux p_hd cur_bindings hd in let? with_arg = interp_pattern_aux p_arg with_hd arg in return with_arg | _ -> raise (SimpleMismatch (pat, tm)) in match pat with | PVar var -> interp_var var cur_bindings tm | PQn qn -> interp_qn qn cur_bindings tm | PType -> interp_type cur_bindings tm | PApp p_hd p_arg -> interp_app p_hd p_arg cur_bindings tm (** Match a pattern `pat` against a term. Returns a result in the exception monad. **) let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) = fun (tm: term) -> let? rev_bindings = interp_pattern_aux pat [] tm in return (List.Tot.Base.rev rev_bindings) (** Match a term `tm` against a pattern `pat`. Raises an exception if the match fails. This is mostly useful for debugging: use ``mgw`` to capture matches. **) let match_term pat (tm : term) : Tac bindings = match interp_pattern pat (norm_term [] tm) with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern-matching problems /// ========================= /// /// Generalizing past single-term single-pattern problems, we obtain the /// following notions of pattern-matching problems and solutions: let debug msg : Tac unit = () // print msg /// Definitions /// ----------- let absvar = binding type hypothesis = binding /// A matching problem is composed of holes (``mp_vars``), hypothesis patterns /// (``mp_hyps``), and a goal pattern (``mp_goal``). noeq type matching_problem = { mp_vars: list varname; mp_hyps: list (varname * pattern); mp_goal: option pattern } let string_of_matching_problem mp = let vars = String.concat ", " mp.mp_vars in let hyps = String.concat "\n " (List.Tot.Base.map (fun (nm, pat) -> nm ^ ": " ^ (string_of_pattern pat)) mp.mp_hyps) in let goal = match mp.mp_goal with | None -> "_" | Some pat -> string_of_pattern pat in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ "\n" ^ " goal: " ^ goal ^ " }" /// A solution is composed of terms captured to mach the holes, and binders /// captured to match hypothesis patterns. noeq type matching_solution = { ms_vars: list (varname * term); ms_hyps: list (varname * hypothesis) } let string_of_matching_solution ms = let vars = String.concat "\n " (map (fun (varname, tm) -> varname ^ ": " ^ (term_to_string tm)) ms.ms_vars) in let hyps = String.concat "\n " (map (fun (nm, binding) -> nm ^ ": " ^ (binding_to_string binding)) ms.ms_hyps) in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ " }" (** Find a varname in an association list; fail if it can't be found. **) let assoc_varname_fail (#b: Type) (key: varname) (ls: list (varname * b)) : Tac b = match List.Tot.Base.assoc key ls with | None -> fail ("Not found: " ^ key) | Some x -> x let ms_locate_hyp (a: Type) (solution: matching_solution) (name: varname) : Tac hypothesis = assoc_varname_fail name solution.ms_hyps let ms_locate_var (a: Type) (solution: matching_solution) (name: varname) : Tac a = unquote #a (assoc_varname_fail name solution.ms_vars) let ms_locate_unit (a: Type) _solution _binder_name : Tac unit = () /// Resolution /// ---------- /// /// Solving a matching problem is a two-steps process: find an initial /// assignment for holes based on the goal pattern, then find a set of /// hypotheses matching hypothesis patterns. /// /// Note that the implementation takes a continuation of type /// ``matching_solution -> Tac a``. This continuation is needed because we want /// users to be able to provide extra criteria on matching solutions (most /// commonly, this criterion is that a particular tactic should run /// successfuly). /// /// This makes it easy to implement a simple for of search through the context, /// where one can find a hypothesis matching a particular predicate by /// constructing a trivial matching problem and passing the predicate as the /// continuation. (** Scan ``hypotheses`` for a match for ``pat`` that lets ``body`` succeed. ``name`` is used to refer to the hypothesis matched in the final solution. ``part_sol`` includes bindings gathered while matching previous solutions. **) let rec solve_mp_for_single_hyp #a (name: varname) (pat: pattern) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (part_sol: matching_solution) : Tac a = match hypotheses with | [] -> fail #a "No matching hypothesis" | h :: hs -> or_else // Must be in ``Tac`` here to run `body` (fun () -> match interp_pattern_aux pat part_sol.ms_vars (type_of_binding h) with | Failure ex -> fail ("Failed to match hyp: " ^ (string_of_match_exception ex)) | Success bindings -> let ms_hyps = (name, h) :: part_sol.ms_hyps in body ({ part_sol with ms_vars = bindings; ms_hyps = ms_hyps })) (fun () -> solve_mp_for_single_hyp name pat hs body part_sol) (** Scan ``hypotheses`` for matches for ``mp_hyps`` that lets ``body`` succeed. **) let rec solve_mp_for_hyps #a (mp_hyps: list (varname * pattern)) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (partial_solution: matching_solution) : Tac a = match mp_hyps with | [] -> body partial_solution | (name, pat) :: pats -> solve_mp_for_single_hyp name pat hypotheses (solve_mp_for_hyps pats hypotheses body) partial_solution (** Solve a matching problem. The solution returned is constructed to ensure that the continuation ``body`` succeeds: this implements the usual backtracking-match semantics. **) let solve_mp #a (problem: matching_problem) (hypotheses: list hypothesis) (goal: term) (body: matching_solution -> Tac a) : Tac a = let goal_ps = match problem.mp_goal with | None -> { ms_vars = []; ms_hyps = [] } | Some pat -> match interp_pattern pat goal with | Failure ex -> fail ("Failed to match goal: " ^ (string_of_match_exception ex)) | Success bindings -> { ms_vars = bindings; ms_hyps = [] } in solve_mp_for_hyps #a problem.mp_hyps hypotheses body goal_ps /// A DSL for pattern-matching /// ========================== /// /// Using pattern-matching problems as defined above is relatively cumbersome, /// so we now introduce a lightweight notation, in two steps: pattern notations, /// and matching-problem notations. /// /// Pattern notations /// ----------------- /// /// The first part of our pattern-matching syntax is pattern notations: we /// provide a reflective function which constructs a pattern from a term: /// variables are holes, free variables are constants, and applications are /// application patterns. (* FIXME: MOVE *) let name_of_namedv (x:namedv) : Tac string = unseal (inspect_namedv x).ppname (** Compile a term `tm` into a pattern. **) let rec pattern_of_term_ex tm : Tac (match_res pattern) = match inspect tm with | Tv_Var bv -> return (PVar (name_of_namedv bv)) | Tv_FVar fv | Tv_UInst fv _ -> let qn = fv_to_string fv in return (PQn qn) | Tv_Type _ -> return PType | Tv_App f (x, _) -> let? fpat = pattern_of_term_ex f in let? xpat = pattern_of_term_ex x in return (PApp fpat xpat) | _ -> raise (UnsupportedTermInPattern tm) (** β-reduce a term `tm`. This is useful to remove needles function applications introduced by F*, like ``(fun a b c -> a) 1 2 3``. **) let beta_reduce (tm: term) : Tac term = norm_term [] tm (** Compile a term `tm` into a pattern. **) let pattern_of_term tm : Tac pattern = match pattern_of_term_ex tm with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Problem notations /// ----------------- /// /// We then introduce a DSL for matching problems, best explained on the /// following example:: /// /// (fun (a b c: ①) (h1 h2 h3: hyp ②) (g: pm_goal ③) → ④) /// /// This notation is intended to express a pattern-matching problems with three /// holes ``a``, ``b``, and ``c`` of type ①, matching hypotheses ``h1``, ``h2``, /// and ``h3`` against pattern ② and the goal against the pattern ③. The body /// of the notation (④) is then run with appropriate terms bound to ``a``, /// ``b``, and ``c``, appropriate binders bound to ``h1``, ``h2``, and ``h3``, /// and ``()`` bound to ``g``. /// /// We call these patterns ``abspat``s (abstraction patterns), and we provide /// facilities to parse them into matching problems, and to run their bodies /// against a particular matching solution. // We used to annotate variables with an explicit 'var' marker, but then that // var annotation leaked into the types of other hypotheses due to type // inference, requiring non-trivial normalization. // let var (a: Type) = a let hyp (a: Type) = binding let pm_goal (a: Type) = unit let hyp_qn = `%hyp let goal_qn = `%pm_goal noeq type abspat_binder_kind = | ABKVar of typ | ABKHyp | ABKGoal let string_of_abspat_binder_kind = function | ABKVar _ -> "varname" | ABKHyp -> "hyp" | ABKGoal -> "goal" noeq type abspat_argspec = { asa_name: absvar; asa_kind: abspat_binder_kind } // We must store this continuation, because recomputing it yields different // names when the binders are re-opened. type abspat_continuation = list abspat_argspec * term let type_of_named_binder (nb : binder) : term = nb.sort let classify_abspat_binder (b : binder): Tac (abspat_binder_kind * term) = let varname = "v" in let hyp_pat = PApp (PQn hyp_qn) (PVar varname) in let goal_pat = PApp (PQn goal_qn) (PVar varname) in let typ = type_of_named_binder b in match interp_pattern hyp_pat typ with | Success [(_, hyp_typ)] -> ABKHyp, hyp_typ | Success _ -> fail "classifiy_abspat_binder: impossible (1)" | Failure _ -> match interp_pattern goal_pat typ with | Success [(_, goal_typ)] -> ABKGoal, goal_typ | Success _ -> fail "classifiy_abspat_binder: impossible (2)" | Failure _ -> ABKVar typ, typ (** Split an abstraction `tm` into a list of binders and a body. **) let rec binders_and_body_of_abs tm : Tac (list binder * term) = match inspect tm with | Tv_Abs binder tm -> let binders, body = binders_and_body_of_abs tm in binder :: binders, body | _ -> [], tm let cleanup_abspat (t: term) : Tac term = norm_term [] t let name_of_named_binder (nb : binder) : Tac string = unseal nb.ppname (** Parse a notation into a matching problem and a continuation. Pattern-matching notations are of the form ``(fun binders… -> continuation)``, where ``binders`` are of one of the forms ``var …``, ``hyp …``, or ``goal …``. ``var`` binders are typed holes to be used in other binders; ``hyp`` binders indicate a pattern to be matched against hypotheses; and ``goal`` binders match the goal. A reduction phase is run to ensure that the pattern looks reasonable; it is needed because F* tends to infer arguments in β-expanded form. The continuation returned can't directly be applied to a pattern-matching solution; see ``interp_abspat_continuation`` below for that. **) let matching_problem_of_abs (tm: term) : Tac (matching_problem * abspat_continuation) = let binders, body = binders_and_body_of_abs (cleanup_abspat tm) in debug ("Got binders: " ^ (String.concat ", " (map (fun b -> name_of_named_binder b <: Tac string) binders))); let classified_binders : list (binder & string & abspat_binder_kind & typ) = map (fun binder -> let bv_name = name_of_named_binder binder in debug ("Got binder: " ^ bv_name ^ "; type is " ^ term_to_string (type_of_named_binder binder)); let binder_kind, typ = classify_abspat_binder binder in (binder, bv_name, binder_kind, typ)) binders in let problem = fold_left (fun problem (binder, bv_name, binder_kind, typ) -> debug ("Compiling binder " ^ name_of_named_binder binder ^ ", classified as " ^ string_of_abspat_binder_kind binder_kind ^ ", with type " ^ term_to_string typ); match binder_kind with | ABKVar _ -> { problem with mp_vars = bv_name :: problem.mp_vars } | ABKHyp -> { problem with mp_hyps = (bv_name, (pattern_of_term typ)) :: problem.mp_hyps } | ABKGoal -> { problem with mp_goal = Some (pattern_of_term typ) }) ({ mp_vars = []; mp_hyps = []; mp_goal = None }) classified_binders in let continuation = let abspat_argspec_of_binder xx : Tac abspat_argspec = match xx with | (binder, xx, binder_kind, yy) -> { asa_name = binder_to_binding binder; asa_kind = binder_kind } in (map abspat_argspec_of_binder classified_binders, tm) in let mp = { mp_vars = List.Tot.Base.rev #varname problem.mp_vars; mp_hyps = List.Tot.Base.rev #(varname * pattern) problem.mp_hyps; mp_goal = problem.mp_goal } in debug ("Got matching problem: " ^ (string_of_matching_problem mp)); mp, continuation /// Continuations /// ------------- /// /// Parsing an abspat yields a matching problem and a continuation of type /// ``abspat_continuation``, which is essentially just a list of binders and a /// term (the body of the abstraction pattern). (** Get the (quoted) type expected by a specific kind of abspat binder. **) let arg_type_of_binder_kind binder_kind : Tac term = match binder_kind with | ABKVar typ -> typ | ABKHyp -> `binder | ABKGoal -> `unit (** Retrieve the function used to locate a value for a given abspat binder. **) let locate_fn_of_binder_kind binder_kind = match binder_kind with | ABKVar _ -> `ms_locate_var | ABKHyp -> `ms_locate_hyp | ABKGoal -> `ms_locate_unit (** Construct a term fetching the value of an abspat argument from a quoted matching solution ``solution_term``. **) let abspat_arg_of_abspat_argspec solution_term (argspec: abspat_argspec) : Tac term = let loc_fn = locate_fn_of_binder_kind argspec.asa_kind in let name_tm = pack (Tv_Const (C_String (unseal argspec.asa_name.ppname))) in let locate_args = [(arg_type_of_binder_kind argspec.asa_kind, Q_Explicit); (solution_term, Q_Explicit); (name_tm, Q_Explicit)] in mk_app loc_fn locate_args (** Specialize a continuation of type ``abspat_continuation``. This constructs a fully applied version of `continuation`, but it requires a quoted solution to be passed in. **) let rec hoist_and_apply (head:term) (arg_terms:list term) (hoisted_args:list argv) : Tac term = match arg_terms with | [] -> mk_app head (List.rev hoisted_args) | arg_term::rest -> let n = List.Tot.length hoisted_args in //let bv = fresh_bv_named ("x" ^ (string_of_int n)) in let nb : binder = { ppname = seal ("x" ^ string_of_int n); sort = pack Tv_Unknown; uniq = fresh (); qual = Q_Explicit; attrs = [] ; } in pack (Tv_Let false [] nb arg_term (hoist_and_apply head rest ((pack (Tv_Var (binder_to_namedv nb)), Q_Explicit)::hoisted_args)))

continuation: FStar.Tactics.PatternMatching.abspat_continuation -> solution_term: FStar.Tactics.NamedView.term -> FStar.Tactics.Effect.Tac FStar.Tactics.NamedView.term

FStar.Tactics.Effect.Tac

let specialize_abspat_continuation' (continuation: abspat_continuation) (solution_term: term) : Tac term =

let mk_arg_term argspec = abspat_arg_of_abspat_argspec solution_term argspec in let argspecs, body = continuation in hoist_and_apply body (map mk_arg_term argspecs) []

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.interp_abspat_continuation

val interp_abspat_continuation (a: Type0) (continuation: abspat_continuation) : Tac (matching_solution -> Tac a)

val interp_abspat_continuation (a: Type0) (continuation: abspat_continuation) : Tac (matching_solution -> Tac a)

let interp_abspat_continuation (a:Type0) (continuation: abspat_continuation) : Tac (matching_solution -> Tac a) = let applied = specialize_abspat_continuation continuation in unquote #(matching_solution -> Tac a) applied

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp" let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)" /// The exception monad /// ------------------- noeq type match_res a = | Success of a | Failure of match_exception let return #a (x: a) : match_res a = Success x let (let?) (#a #b: Type) (f: match_res a) (g: a -> Tac (match_res b)) : Tac (match_res b) = match f with | Success aa -> g aa | Failure ex -> Failure ex let raise #a (ex: match_exception) : match_res a = Failure ex /// Liftings /// -------- /// /// There's a natural lifting from the exception monad into the tactic effect: let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern interpretation /// ====================== /// /// This section implement pattern-matching. This is strictly a one term, one /// pattern implementation — handling cases in which mutliple hypotheses match /// the same pattern is done later. type bindings = list (varname * term) let string_of_bindings (bindings: bindings) = String.concat "\n" (map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm)) bindings) (** Match a pattern against a term. `cur_bindings` is a list of bindings collected while matching previous parts of the pattern. Returns a result in the exception monad. **) let rec interp_pattern_aux (pat: pattern) (cur_bindings: bindings) (tm:term) : Tac (match_res bindings) = let interp_var (v: varname) cur_bindings tm = match List.Tot.Base.assoc v cur_bindings with | Some tm' -> if term_eq tm tm' then return cur_bindings else raise (NonLinearMismatch (v, tm, tm')) | None -> return ((v, tm) :: cur_bindings) in let interp_qn (qn: qn) cur_bindings tm = match inspect tm with | Tv_UInst fv _ | Tv_FVar fv -> if fv_to_string fv = qn then return cur_bindings else raise (NameMismatch (qn, (fv_to_string fv))) | _ -> raise (SimpleMismatch (pat, tm)) in let interp_type cur_bindings tm = match inspect tm with | Tv_Type _ -> return cur_bindings | _ -> raise (SimpleMismatch (pat, tm)) in let interp_app (p_hd p_arg: (p:pattern{p << pat})) cur_bindings tm = match inspect tm with | Tv_App hd (arg, _) -> let? with_hd = interp_pattern_aux p_hd cur_bindings hd in let? with_arg = interp_pattern_aux p_arg with_hd arg in return with_arg | _ -> raise (SimpleMismatch (pat, tm)) in match pat with | PVar var -> interp_var var cur_bindings tm | PQn qn -> interp_qn qn cur_bindings tm | PType -> interp_type cur_bindings tm | PApp p_hd p_arg -> interp_app p_hd p_arg cur_bindings tm (** Match a pattern `pat` against a term. Returns a result in the exception monad. **) let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) = fun (tm: term) -> let? rev_bindings = interp_pattern_aux pat [] tm in return (List.Tot.Base.rev rev_bindings) (** Match a term `tm` against a pattern `pat`. Raises an exception if the match fails. This is mostly useful for debugging: use ``mgw`` to capture matches. **) let match_term pat (tm : term) : Tac bindings = match interp_pattern pat (norm_term [] tm) with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern-matching problems /// ========================= /// /// Generalizing past single-term single-pattern problems, we obtain the /// following notions of pattern-matching problems and solutions: let debug msg : Tac unit = () // print msg /// Definitions /// ----------- let absvar = binding type hypothesis = binding /// A matching problem is composed of holes (``mp_vars``), hypothesis patterns /// (``mp_hyps``), and a goal pattern (``mp_goal``). noeq type matching_problem = { mp_vars: list varname; mp_hyps: list (varname * pattern); mp_goal: option pattern } let string_of_matching_problem mp = let vars = String.concat ", " mp.mp_vars in let hyps = String.concat "\n " (List.Tot.Base.map (fun (nm, pat) -> nm ^ ": " ^ (string_of_pattern pat)) mp.mp_hyps) in let goal = match mp.mp_goal with | None -> "_" | Some pat -> string_of_pattern pat in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ "\n" ^ " goal: " ^ goal ^ " }" /// A solution is composed of terms captured to mach the holes, and binders /// captured to match hypothesis patterns. noeq type matching_solution = { ms_vars: list (varname * term); ms_hyps: list (varname * hypothesis) } let string_of_matching_solution ms = let vars = String.concat "\n " (map (fun (varname, tm) -> varname ^ ": " ^ (term_to_string tm)) ms.ms_vars) in let hyps = String.concat "\n " (map (fun (nm, binding) -> nm ^ ": " ^ (binding_to_string binding)) ms.ms_hyps) in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ " }" (** Find a varname in an association list; fail if it can't be found. **) let assoc_varname_fail (#b: Type) (key: varname) (ls: list (varname * b)) : Tac b = match List.Tot.Base.assoc key ls with | None -> fail ("Not found: " ^ key) | Some x -> x let ms_locate_hyp (a: Type) (solution: matching_solution) (name: varname) : Tac hypothesis = assoc_varname_fail name solution.ms_hyps let ms_locate_var (a: Type) (solution: matching_solution) (name: varname) : Tac a = unquote #a (assoc_varname_fail name solution.ms_vars) let ms_locate_unit (a: Type) _solution _binder_name : Tac unit = () /// Resolution /// ---------- /// /// Solving a matching problem is a two-steps process: find an initial /// assignment for holes based on the goal pattern, then find a set of /// hypotheses matching hypothesis patterns. /// /// Note that the implementation takes a continuation of type /// ``matching_solution -> Tac a``. This continuation is needed because we want /// users to be able to provide extra criteria on matching solutions (most /// commonly, this criterion is that a particular tactic should run /// successfuly). /// /// This makes it easy to implement a simple for of search through the context, /// where one can find a hypothesis matching a particular predicate by /// constructing a trivial matching problem and passing the predicate as the /// continuation. (** Scan ``hypotheses`` for a match for ``pat`` that lets ``body`` succeed. ``name`` is used to refer to the hypothesis matched in the final solution. ``part_sol`` includes bindings gathered while matching previous solutions. **) let rec solve_mp_for_single_hyp #a (name: varname) (pat: pattern) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (part_sol: matching_solution) : Tac a = match hypotheses with | [] -> fail #a "No matching hypothesis" | h :: hs -> or_else // Must be in ``Tac`` here to run `body` (fun () -> match interp_pattern_aux pat part_sol.ms_vars (type_of_binding h) with | Failure ex -> fail ("Failed to match hyp: " ^ (string_of_match_exception ex)) | Success bindings -> let ms_hyps = (name, h) :: part_sol.ms_hyps in body ({ part_sol with ms_vars = bindings; ms_hyps = ms_hyps })) (fun () -> solve_mp_for_single_hyp name pat hs body part_sol) (** Scan ``hypotheses`` for matches for ``mp_hyps`` that lets ``body`` succeed. **) let rec solve_mp_for_hyps #a (mp_hyps: list (varname * pattern)) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (partial_solution: matching_solution) : Tac a = match mp_hyps with | [] -> body partial_solution | (name, pat) :: pats -> solve_mp_for_single_hyp name pat hypotheses (solve_mp_for_hyps pats hypotheses body) partial_solution (** Solve a matching problem. The solution returned is constructed to ensure that the continuation ``body`` succeeds: this implements the usual backtracking-match semantics. **) let solve_mp #a (problem: matching_problem) (hypotheses: list hypothesis) (goal: term) (body: matching_solution -> Tac a) : Tac a = let goal_ps = match problem.mp_goal with | None -> { ms_vars = []; ms_hyps = [] } | Some pat -> match interp_pattern pat goal with | Failure ex -> fail ("Failed to match goal: " ^ (string_of_match_exception ex)) | Success bindings -> { ms_vars = bindings; ms_hyps = [] } in solve_mp_for_hyps #a problem.mp_hyps hypotheses body goal_ps /// A DSL for pattern-matching /// ========================== /// /// Using pattern-matching problems as defined above is relatively cumbersome, /// so we now introduce a lightweight notation, in two steps: pattern notations, /// and matching-problem notations. /// /// Pattern notations /// ----------------- /// /// The first part of our pattern-matching syntax is pattern notations: we /// provide a reflective function which constructs a pattern from a term: /// variables are holes, free variables are constants, and applications are /// application patterns. (* FIXME: MOVE *) let name_of_namedv (x:namedv) : Tac string = unseal (inspect_namedv x).ppname (** Compile a term `tm` into a pattern. **) let rec pattern_of_term_ex tm : Tac (match_res pattern) = match inspect tm with | Tv_Var bv -> return (PVar (name_of_namedv bv)) | Tv_FVar fv | Tv_UInst fv _ -> let qn = fv_to_string fv in return (PQn qn) | Tv_Type _ -> return PType | Tv_App f (x, _) -> let? fpat = pattern_of_term_ex f in let? xpat = pattern_of_term_ex x in return (PApp fpat xpat) | _ -> raise (UnsupportedTermInPattern tm) (** β-reduce a term `tm`. This is useful to remove needles function applications introduced by F*, like ``(fun a b c -> a) 1 2 3``. **) let beta_reduce (tm: term) : Tac term = norm_term [] tm (** Compile a term `tm` into a pattern. **) let pattern_of_term tm : Tac pattern = match pattern_of_term_ex tm with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Problem notations /// ----------------- /// /// We then introduce a DSL for matching problems, best explained on the /// following example:: /// /// (fun (a b c: ①) (h1 h2 h3: hyp ②) (g: pm_goal ③) → ④) /// /// This notation is intended to express a pattern-matching problems with three /// holes ``a``, ``b``, and ``c`` of type ①, matching hypotheses ``h1``, ``h2``, /// and ``h3`` against pattern ② and the goal against the pattern ③. The body /// of the notation (④) is then run with appropriate terms bound to ``a``, /// ``b``, and ``c``, appropriate binders bound to ``h1``, ``h2``, and ``h3``, /// and ``()`` bound to ``g``. /// /// We call these patterns ``abspat``s (abstraction patterns), and we provide /// facilities to parse them into matching problems, and to run their bodies /// against a particular matching solution. // We used to annotate variables with an explicit 'var' marker, but then that // var annotation leaked into the types of other hypotheses due to type // inference, requiring non-trivial normalization. // let var (a: Type) = a let hyp (a: Type) = binding let pm_goal (a: Type) = unit let hyp_qn = `%hyp let goal_qn = `%pm_goal noeq type abspat_binder_kind = | ABKVar of typ | ABKHyp | ABKGoal let string_of_abspat_binder_kind = function | ABKVar _ -> "varname" | ABKHyp -> "hyp" | ABKGoal -> "goal" noeq type abspat_argspec = { asa_name: absvar; asa_kind: abspat_binder_kind } // We must store this continuation, because recomputing it yields different // names when the binders are re-opened. type abspat_continuation = list abspat_argspec * term let type_of_named_binder (nb : binder) : term = nb.sort let classify_abspat_binder (b : binder): Tac (abspat_binder_kind * term) = let varname = "v" in let hyp_pat = PApp (PQn hyp_qn) (PVar varname) in let goal_pat = PApp (PQn goal_qn) (PVar varname) in let typ = type_of_named_binder b in match interp_pattern hyp_pat typ with | Success [(_, hyp_typ)] -> ABKHyp, hyp_typ | Success _ -> fail "classifiy_abspat_binder: impossible (1)" | Failure _ -> match interp_pattern goal_pat typ with | Success [(_, goal_typ)] -> ABKGoal, goal_typ | Success _ -> fail "classifiy_abspat_binder: impossible (2)" | Failure _ -> ABKVar typ, typ (** Split an abstraction `tm` into a list of binders and a body. **) let rec binders_and_body_of_abs tm : Tac (list binder * term) = match inspect tm with | Tv_Abs binder tm -> let binders, body = binders_and_body_of_abs tm in binder :: binders, body | _ -> [], tm let cleanup_abspat (t: term) : Tac term = norm_term [] t let name_of_named_binder (nb : binder) : Tac string = unseal nb.ppname (** Parse a notation into a matching problem and a continuation. Pattern-matching notations are of the form ``(fun binders… -> continuation)``, where ``binders`` are of one of the forms ``var …``, ``hyp …``, or ``goal …``. ``var`` binders are typed holes to be used in other binders; ``hyp`` binders indicate a pattern to be matched against hypotheses; and ``goal`` binders match the goal. A reduction phase is run to ensure that the pattern looks reasonable; it is needed because F* tends to infer arguments in β-expanded form. The continuation returned can't directly be applied to a pattern-matching solution; see ``interp_abspat_continuation`` below for that. **) let matching_problem_of_abs (tm: term) : Tac (matching_problem * abspat_continuation) = let binders, body = binders_and_body_of_abs (cleanup_abspat tm) in debug ("Got binders: " ^ (String.concat ", " (map (fun b -> name_of_named_binder b <: Tac string) binders))); let classified_binders : list (binder & string & abspat_binder_kind & typ) = map (fun binder -> let bv_name = name_of_named_binder binder in debug ("Got binder: " ^ bv_name ^ "; type is " ^ term_to_string (type_of_named_binder binder)); let binder_kind, typ = classify_abspat_binder binder in (binder, bv_name, binder_kind, typ)) binders in let problem = fold_left (fun problem (binder, bv_name, binder_kind, typ) -> debug ("Compiling binder " ^ name_of_named_binder binder ^ ", classified as " ^ string_of_abspat_binder_kind binder_kind ^ ", with type " ^ term_to_string typ); match binder_kind with | ABKVar _ -> { problem with mp_vars = bv_name :: problem.mp_vars } | ABKHyp -> { problem with mp_hyps = (bv_name, (pattern_of_term typ)) :: problem.mp_hyps } | ABKGoal -> { problem with mp_goal = Some (pattern_of_term typ) }) ({ mp_vars = []; mp_hyps = []; mp_goal = None }) classified_binders in let continuation = let abspat_argspec_of_binder xx : Tac abspat_argspec = match xx with | (binder, xx, binder_kind, yy) -> { asa_name = binder_to_binding binder; asa_kind = binder_kind } in (map abspat_argspec_of_binder classified_binders, tm) in let mp = { mp_vars = List.Tot.Base.rev #varname problem.mp_vars; mp_hyps = List.Tot.Base.rev #(varname * pattern) problem.mp_hyps; mp_goal = problem.mp_goal } in debug ("Got matching problem: " ^ (string_of_matching_problem mp)); mp, continuation /// Continuations /// ------------- /// /// Parsing an abspat yields a matching problem and a continuation of type /// ``abspat_continuation``, which is essentially just a list of binders and a /// term (the body of the abstraction pattern). (** Get the (quoted) type expected by a specific kind of abspat binder. **) let arg_type_of_binder_kind binder_kind : Tac term = match binder_kind with | ABKVar typ -> typ | ABKHyp -> `binder | ABKGoal -> `unit (** Retrieve the function used to locate a value for a given abspat binder. **) let locate_fn_of_binder_kind binder_kind = match binder_kind with | ABKVar _ -> `ms_locate_var | ABKHyp -> `ms_locate_hyp | ABKGoal -> `ms_locate_unit (** Construct a term fetching the value of an abspat argument from a quoted matching solution ``solution_term``. **) let abspat_arg_of_abspat_argspec solution_term (argspec: abspat_argspec) : Tac term = let loc_fn = locate_fn_of_binder_kind argspec.asa_kind in let name_tm = pack (Tv_Const (C_String (unseal argspec.asa_name.ppname))) in let locate_args = [(arg_type_of_binder_kind argspec.asa_kind, Q_Explicit); (solution_term, Q_Explicit); (name_tm, Q_Explicit)] in mk_app loc_fn locate_args (** Specialize a continuation of type ``abspat_continuation``. This constructs a fully applied version of `continuation`, but it requires a quoted solution to be passed in. **) let rec hoist_and_apply (head:term) (arg_terms:list term) (hoisted_args:list argv) : Tac term = match arg_terms with | [] -> mk_app head (List.rev hoisted_args) | arg_term::rest -> let n = List.Tot.length hoisted_args in //let bv = fresh_bv_named ("x" ^ (string_of_int n)) in let nb : binder = { ppname = seal ("x" ^ string_of_int n); sort = pack Tv_Unknown; uniq = fresh (); qual = Q_Explicit; attrs = [] ; } in pack (Tv_Let false [] nb arg_term (hoist_and_apply head rest ((pack (Tv_Var (binder_to_namedv nb)), Q_Explicit)::hoisted_args))) let specialize_abspat_continuation' (continuation: abspat_continuation) (solution_term:term) : Tac term = let mk_arg_term argspec = abspat_arg_of_abspat_argspec solution_term argspec in let argspecs, body = continuation in hoist_and_apply body (map mk_arg_term argspecs) [] (** Specialize a continuation of type ``abspat_continuation``. This yields a quoted function taking a matching solution and running its body with appropriate bindings. **) let specialize_abspat_continuation (continuation: abspat_continuation) : Tac term = let solution_binder = fresh_binder (`matching_solution) in let solution_term = pack (Tv_Var (binder_to_namedv solution_binder)) in let applied = specialize_abspat_continuation' continuation solution_term in let thunked = pack (Tv_Abs solution_binder applied) in debug ("Specialized into " ^ (term_to_string thunked)); let normalized = beta_reduce thunked in debug ("… which reduces to " ^ (term_to_string normalized)); thunked (** Interpret a continuation of type ``abspat_continuation``. This yields a function taking a matching solution and running the body of the

a: Type0 -> continuation: FStar.Tactics.PatternMatching.abspat_continuation -> FStar.Tactics.Effect.Tac (_: FStar.Tactics.PatternMatching.matching_solution -> FStar.Tactics.Effect.Tac a)

FStar.Tactics.Effect.Tac

let interp_abspat_continuation (a: Type0) (continuation: abspat_continuation) : Tac (matching_solution -> Tac a) =

let applied = specialize_abspat_continuation continuation in unquote #(matching_solution -> Tac a) applied

MerkleTree.Spec.fst

MerkleTree.Spec.op_String_Access

val op_String_Access : s: FStar.Seq.Base.seq MerkleTree.Spec.padded_hash -> i: Prims.nat{i < FStar.Seq.Base.length s} -> MerkleTree.Spec.padded_hash

let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz)

module MerkleTree.Spec open FStar.Classical open FStar.Mul open FStar.Seq module S = FStar.Seq #set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10" // For SHA2_256, this is is a sequence of 32 bytes // These are secret bytes, hence not an eqtype type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz } type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz) val sha256_compress: hash_fun_t #32 let sha256_compress src1 src2 = let sz = Spec.Hash.Definitions.SHA2_256 in let hash_alg = Spec.Hash.Definitions.SHA2_256 in let acc = Spec.Agile.Hash.init hash_alg in let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in Spec.Agile.Hash.finish hash_alg acc () /// For simplicity, we will specify the root for a sequence of [i] /// tags where [i <= 2^n] as the root of a full binary tree with [2^n] /// leaves obtained by padding the sequence with dummies. This /// requires extending the definitions of hashes and hash functions. Our /// extended definition of hash justifies skipping any concrete /// computation on dummies. noeq type padded_hash #hsz = | HRaw: hr:hash #hsz -> padded_hash #hsz | HPad // right padding to make the size of a Merkle tree a power of 2 val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz) let padded_hash_fun #hsz f lh rh = allow_inversion (padded_hash #hsz); match lh, rh with | HPad , _ -> HPad | _ , HPad -> lh | HRaw lhr, HRaw rhr -> HRaw (f lhr rhr) noextract val hashes (#hsz:pos): Type0 let hashes #hsz = S.seq (padded_hash #hsz) type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n} val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz) let mt_get #_ #_ mt idx = S.index mt idx

s: FStar.Seq.Base.seq MerkleTree.Spec.padded_hash -> i: Prims.nat{i < FStar.Seq.Base.length s} -> MerkleTree.Spec.padded_hash

Prims.Tot

let ( .[] ) (#hsz: pos) =

S.index #(padded_hash #hsz)

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.inspect_abspat_solution

val inspect_abspat_solution (#a: _) (abspat: a) : Tac matching_solution

val inspect_abspat_solution (#a: _) (abspat: a) : Tac matching_solution

let inspect_abspat_solution #a (abspat: a) : Tac matching_solution = match_abspat abspat (fun _ -> (fun solution -> solution <: Tac _) <: Tac _)

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp" let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)" /// The exception monad /// ------------------- noeq type match_res a = | Success of a | Failure of match_exception let return #a (x: a) : match_res a = Success x let (let?) (#a #b: Type) (f: match_res a) (g: a -> Tac (match_res b)) : Tac (match_res b) = match f with | Success aa -> g aa | Failure ex -> Failure ex let raise #a (ex: match_exception) : match_res a = Failure ex /// Liftings /// -------- /// /// There's a natural lifting from the exception monad into the tactic effect: let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern interpretation /// ====================== /// /// This section implement pattern-matching. This is strictly a one term, one /// pattern implementation — handling cases in which mutliple hypotheses match /// the same pattern is done later. type bindings = list (varname * term) let string_of_bindings (bindings: bindings) = String.concat "\n" (map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm)) bindings) (** Match a pattern against a term. `cur_bindings` is a list of bindings collected while matching previous parts of the pattern. Returns a result in the exception monad. **) let rec interp_pattern_aux (pat: pattern) (cur_bindings: bindings) (tm:term) : Tac (match_res bindings) = let interp_var (v: varname) cur_bindings tm = match List.Tot.Base.assoc v cur_bindings with | Some tm' -> if term_eq tm tm' then return cur_bindings else raise (NonLinearMismatch (v, tm, tm')) | None -> return ((v, tm) :: cur_bindings) in let interp_qn (qn: qn) cur_bindings tm = match inspect tm with | Tv_UInst fv _ | Tv_FVar fv -> if fv_to_string fv = qn then return cur_bindings else raise (NameMismatch (qn, (fv_to_string fv))) | _ -> raise (SimpleMismatch (pat, tm)) in let interp_type cur_bindings tm = match inspect tm with | Tv_Type _ -> return cur_bindings | _ -> raise (SimpleMismatch (pat, tm)) in let interp_app (p_hd p_arg: (p:pattern{p << pat})) cur_bindings tm = match inspect tm with | Tv_App hd (arg, _) -> let? with_hd = interp_pattern_aux p_hd cur_bindings hd in let? with_arg = interp_pattern_aux p_arg with_hd arg in return with_arg | _ -> raise (SimpleMismatch (pat, tm)) in match pat with | PVar var -> interp_var var cur_bindings tm | PQn qn -> interp_qn qn cur_bindings tm | PType -> interp_type cur_bindings tm | PApp p_hd p_arg -> interp_app p_hd p_arg cur_bindings tm (** Match a pattern `pat` against a term. Returns a result in the exception monad. **) let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) = fun (tm: term) -> let? rev_bindings = interp_pattern_aux pat [] tm in return (List.Tot.Base.rev rev_bindings) (** Match a term `tm` against a pattern `pat`. Raises an exception if the match fails. This is mostly useful for debugging: use ``mgw`` to capture matches. **) let match_term pat (tm : term) : Tac bindings = match interp_pattern pat (norm_term [] tm) with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern-matching problems /// ========================= /// /// Generalizing past single-term single-pattern problems, we obtain the /// following notions of pattern-matching problems and solutions: let debug msg : Tac unit = () // print msg /// Definitions /// ----------- let absvar = binding type hypothesis = binding /// A matching problem is composed of holes (``mp_vars``), hypothesis patterns /// (``mp_hyps``), and a goal pattern (``mp_goal``). noeq type matching_problem = { mp_vars: list varname; mp_hyps: list (varname * pattern); mp_goal: option pattern } let string_of_matching_problem mp = let vars = String.concat ", " mp.mp_vars in let hyps = String.concat "\n " (List.Tot.Base.map (fun (nm, pat) -> nm ^ ": " ^ (string_of_pattern pat)) mp.mp_hyps) in let goal = match mp.mp_goal with | None -> "_" | Some pat -> string_of_pattern pat in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ "\n" ^ " goal: " ^ goal ^ " }" /// A solution is composed of terms captured to mach the holes, and binders /// captured to match hypothesis patterns. noeq type matching_solution = { ms_vars: list (varname * term); ms_hyps: list (varname * hypothesis) } let string_of_matching_solution ms = let vars = String.concat "\n " (map (fun (varname, tm) -> varname ^ ": " ^ (term_to_string tm)) ms.ms_vars) in let hyps = String.concat "\n " (map (fun (nm, binding) -> nm ^ ": " ^ (binding_to_string binding)) ms.ms_hyps) in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ " }" (** Find a varname in an association list; fail if it can't be found. **) let assoc_varname_fail (#b: Type) (key: varname) (ls: list (varname * b)) : Tac b = match List.Tot.Base.assoc key ls with | None -> fail ("Not found: " ^ key) | Some x -> x let ms_locate_hyp (a: Type) (solution: matching_solution) (name: varname) : Tac hypothesis = assoc_varname_fail name solution.ms_hyps let ms_locate_var (a: Type) (solution: matching_solution) (name: varname) : Tac a = unquote #a (assoc_varname_fail name solution.ms_vars) let ms_locate_unit (a: Type) _solution _binder_name : Tac unit = () /// Resolution /// ---------- /// /// Solving a matching problem is a two-steps process: find an initial /// assignment for holes based on the goal pattern, then find a set of /// hypotheses matching hypothesis patterns. /// /// Note that the implementation takes a continuation of type /// ``matching_solution -> Tac a``. This continuation is needed because we want /// users to be able to provide extra criteria on matching solutions (most /// commonly, this criterion is that a particular tactic should run /// successfuly). /// /// This makes it easy to implement a simple for of search through the context, /// where one can find a hypothesis matching a particular predicate by /// constructing a trivial matching problem and passing the predicate as the /// continuation. (** Scan ``hypotheses`` for a match for ``pat`` that lets ``body`` succeed. ``name`` is used to refer to the hypothesis matched in the final solution. ``part_sol`` includes bindings gathered while matching previous solutions. **) let rec solve_mp_for_single_hyp #a (name: varname) (pat: pattern) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (part_sol: matching_solution) : Tac a = match hypotheses with | [] -> fail #a "No matching hypothesis" | h :: hs -> or_else // Must be in ``Tac`` here to run `body` (fun () -> match interp_pattern_aux pat part_sol.ms_vars (type_of_binding h) with | Failure ex -> fail ("Failed to match hyp: " ^ (string_of_match_exception ex)) | Success bindings -> let ms_hyps = (name, h) :: part_sol.ms_hyps in body ({ part_sol with ms_vars = bindings; ms_hyps = ms_hyps })) (fun () -> solve_mp_for_single_hyp name pat hs body part_sol) (** Scan ``hypotheses`` for matches for ``mp_hyps`` that lets ``body`` succeed. **) let rec solve_mp_for_hyps #a (mp_hyps: list (varname * pattern)) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (partial_solution: matching_solution) : Tac a = match mp_hyps with | [] -> body partial_solution | (name, pat) :: pats -> solve_mp_for_single_hyp name pat hypotheses (solve_mp_for_hyps pats hypotheses body) partial_solution (** Solve a matching problem. The solution returned is constructed to ensure that the continuation ``body`` succeeds: this implements the usual backtracking-match semantics. **) let solve_mp #a (problem: matching_problem) (hypotheses: list hypothesis) (goal: term) (body: matching_solution -> Tac a) : Tac a = let goal_ps = match problem.mp_goal with | None -> { ms_vars = []; ms_hyps = [] } | Some pat -> match interp_pattern pat goal with | Failure ex -> fail ("Failed to match goal: " ^ (string_of_match_exception ex)) | Success bindings -> { ms_vars = bindings; ms_hyps = [] } in solve_mp_for_hyps #a problem.mp_hyps hypotheses body goal_ps /// A DSL for pattern-matching /// ========================== /// /// Using pattern-matching problems as defined above is relatively cumbersome, /// so we now introduce a lightweight notation, in two steps: pattern notations, /// and matching-problem notations. /// /// Pattern notations /// ----------------- /// /// The first part of our pattern-matching syntax is pattern notations: we /// provide a reflective function which constructs a pattern from a term: /// variables are holes, free variables are constants, and applications are /// application patterns. (* FIXME: MOVE *) let name_of_namedv (x:namedv) : Tac string = unseal (inspect_namedv x).ppname (** Compile a term `tm` into a pattern. **) let rec pattern_of_term_ex tm : Tac (match_res pattern) = match inspect tm with | Tv_Var bv -> return (PVar (name_of_namedv bv)) | Tv_FVar fv | Tv_UInst fv _ -> let qn = fv_to_string fv in return (PQn qn) | Tv_Type _ -> return PType | Tv_App f (x, _) -> let? fpat = pattern_of_term_ex f in let? xpat = pattern_of_term_ex x in return (PApp fpat xpat) | _ -> raise (UnsupportedTermInPattern tm) (** β-reduce a term `tm`. This is useful to remove needles function applications introduced by F*, like ``(fun a b c -> a) 1 2 3``. **) let beta_reduce (tm: term) : Tac term = norm_term [] tm (** Compile a term `tm` into a pattern. **) let pattern_of_term tm : Tac pattern = match pattern_of_term_ex tm with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Problem notations /// ----------------- /// /// We then introduce a DSL for matching problems, best explained on the /// following example:: /// /// (fun (a b c: ①) (h1 h2 h3: hyp ②) (g: pm_goal ③) → ④) /// /// This notation is intended to express a pattern-matching problems with three /// holes ``a``, ``b``, and ``c`` of type ①, matching hypotheses ``h1``, ``h2``, /// and ``h3`` against pattern ② and the goal against the pattern ③. The body /// of the notation (④) is then run with appropriate terms bound to ``a``, /// ``b``, and ``c``, appropriate binders bound to ``h1``, ``h2``, and ``h3``, /// and ``()`` bound to ``g``. /// /// We call these patterns ``abspat``s (abstraction patterns), and we provide /// facilities to parse them into matching problems, and to run their bodies /// against a particular matching solution. // We used to annotate variables with an explicit 'var' marker, but then that // var annotation leaked into the types of other hypotheses due to type // inference, requiring non-trivial normalization. // let var (a: Type) = a let hyp (a: Type) = binding let pm_goal (a: Type) = unit let hyp_qn = `%hyp let goal_qn = `%pm_goal noeq type abspat_binder_kind = | ABKVar of typ | ABKHyp | ABKGoal let string_of_abspat_binder_kind = function | ABKVar _ -> "varname" | ABKHyp -> "hyp" | ABKGoal -> "goal" noeq type abspat_argspec = { asa_name: absvar; asa_kind: abspat_binder_kind } // We must store this continuation, because recomputing it yields different // names when the binders are re-opened. type abspat_continuation = list abspat_argspec * term let type_of_named_binder (nb : binder) : term = nb.sort let classify_abspat_binder (b : binder): Tac (abspat_binder_kind * term) = let varname = "v" in let hyp_pat = PApp (PQn hyp_qn) (PVar varname) in let goal_pat = PApp (PQn goal_qn) (PVar varname) in let typ = type_of_named_binder b in match interp_pattern hyp_pat typ with | Success [(_, hyp_typ)] -> ABKHyp, hyp_typ | Success _ -> fail "classifiy_abspat_binder: impossible (1)" | Failure _ -> match interp_pattern goal_pat typ with | Success [(_, goal_typ)] -> ABKGoal, goal_typ | Success _ -> fail "classifiy_abspat_binder: impossible (2)" | Failure _ -> ABKVar typ, typ (** Split an abstraction `tm` into a list of binders and a body. **) let rec binders_and_body_of_abs tm : Tac (list binder * term) = match inspect tm with | Tv_Abs binder tm -> let binders, body = binders_and_body_of_abs tm in binder :: binders, body | _ -> [], tm let cleanup_abspat (t: term) : Tac term = norm_term [] t let name_of_named_binder (nb : binder) : Tac string = unseal nb.ppname (** Parse a notation into a matching problem and a continuation. Pattern-matching notations are of the form ``(fun binders… -> continuation)``, where ``binders`` are of one of the forms ``var …``, ``hyp …``, or ``goal …``. ``var`` binders are typed holes to be used in other binders; ``hyp`` binders indicate a pattern to be matched against hypotheses; and ``goal`` binders match the goal. A reduction phase is run to ensure that the pattern looks reasonable; it is needed because F* tends to infer arguments in β-expanded form. The continuation returned can't directly be applied to a pattern-matching solution; see ``interp_abspat_continuation`` below for that. **) let matching_problem_of_abs (tm: term) : Tac (matching_problem * abspat_continuation) = let binders, body = binders_and_body_of_abs (cleanup_abspat tm) in debug ("Got binders: " ^ (String.concat ", " (map (fun b -> name_of_named_binder b <: Tac string) binders))); let classified_binders : list (binder & string & abspat_binder_kind & typ) = map (fun binder -> let bv_name = name_of_named_binder binder in debug ("Got binder: " ^ bv_name ^ "; type is " ^ term_to_string (type_of_named_binder binder)); let binder_kind, typ = classify_abspat_binder binder in (binder, bv_name, binder_kind, typ)) binders in let problem = fold_left (fun problem (binder, bv_name, binder_kind, typ) -> debug ("Compiling binder " ^ name_of_named_binder binder ^ ", classified as " ^ string_of_abspat_binder_kind binder_kind ^ ", with type " ^ term_to_string typ); match binder_kind with | ABKVar _ -> { problem with mp_vars = bv_name :: problem.mp_vars } | ABKHyp -> { problem with mp_hyps = (bv_name, (pattern_of_term typ)) :: problem.mp_hyps } | ABKGoal -> { problem with mp_goal = Some (pattern_of_term typ) }) ({ mp_vars = []; mp_hyps = []; mp_goal = None }) classified_binders in let continuation = let abspat_argspec_of_binder xx : Tac abspat_argspec = match xx with | (binder, xx, binder_kind, yy) -> { asa_name = binder_to_binding binder; asa_kind = binder_kind } in (map abspat_argspec_of_binder classified_binders, tm) in let mp = { mp_vars = List.Tot.Base.rev #varname problem.mp_vars; mp_hyps = List.Tot.Base.rev #(varname * pattern) problem.mp_hyps; mp_goal = problem.mp_goal } in debug ("Got matching problem: " ^ (string_of_matching_problem mp)); mp, continuation /// Continuations /// ------------- /// /// Parsing an abspat yields a matching problem and a continuation of type /// ``abspat_continuation``, which is essentially just a list of binders and a /// term (the body of the abstraction pattern). (** Get the (quoted) type expected by a specific kind of abspat binder. **) let arg_type_of_binder_kind binder_kind : Tac term = match binder_kind with | ABKVar typ -> typ | ABKHyp -> `binder | ABKGoal -> `unit (** Retrieve the function used to locate a value for a given abspat binder. **) let locate_fn_of_binder_kind binder_kind = match binder_kind with | ABKVar _ -> `ms_locate_var | ABKHyp -> `ms_locate_hyp | ABKGoal -> `ms_locate_unit (** Construct a term fetching the value of an abspat argument from a quoted matching solution ``solution_term``. **) let abspat_arg_of_abspat_argspec solution_term (argspec: abspat_argspec) : Tac term = let loc_fn = locate_fn_of_binder_kind argspec.asa_kind in let name_tm = pack (Tv_Const (C_String (unseal argspec.asa_name.ppname))) in let locate_args = [(arg_type_of_binder_kind argspec.asa_kind, Q_Explicit); (solution_term, Q_Explicit); (name_tm, Q_Explicit)] in mk_app loc_fn locate_args (** Specialize a continuation of type ``abspat_continuation``. This constructs a fully applied version of `continuation`, but it requires a quoted solution to be passed in. **) let rec hoist_and_apply (head:term) (arg_terms:list term) (hoisted_args:list argv) : Tac term = match arg_terms with | [] -> mk_app head (List.rev hoisted_args) | arg_term::rest -> let n = List.Tot.length hoisted_args in //let bv = fresh_bv_named ("x" ^ (string_of_int n)) in let nb : binder = { ppname = seal ("x" ^ string_of_int n); sort = pack Tv_Unknown; uniq = fresh (); qual = Q_Explicit; attrs = [] ; } in pack (Tv_Let false [] nb arg_term (hoist_and_apply head rest ((pack (Tv_Var (binder_to_namedv nb)), Q_Explicit)::hoisted_args))) let specialize_abspat_continuation' (continuation: abspat_continuation) (solution_term:term) : Tac term = let mk_arg_term argspec = abspat_arg_of_abspat_argspec solution_term argspec in let argspecs, body = continuation in hoist_and_apply body (map mk_arg_term argspecs) [] (** Specialize a continuation of type ``abspat_continuation``. This yields a quoted function taking a matching solution and running its body with appropriate bindings. **) let specialize_abspat_continuation (continuation: abspat_continuation) : Tac term = let solution_binder = fresh_binder (`matching_solution) in let solution_term = pack (Tv_Var (binder_to_namedv solution_binder)) in let applied = specialize_abspat_continuation' continuation solution_term in let thunked = pack (Tv_Abs solution_binder applied) in debug ("Specialized into " ^ (term_to_string thunked)); let normalized = beta_reduce thunked in debug ("… which reduces to " ^ (term_to_string normalized)); thunked (** Interpret a continuation of type ``abspat_continuation``. This yields a function taking a matching solution and running the body of the continuation with appropriate bindings. **) let interp_abspat_continuation (a:Type0) (continuation: abspat_continuation) : Tac (matching_solution -> Tac a) = let applied = specialize_abspat_continuation continuation in unquote #(matching_solution -> Tac a) applied /// Putting it all together /// ======================= /// /// We now have all we need to use pattern-matching, short of a few convenience functions: (** Construct a matching problem from an abspat. **) let interp_abspat #a (abspat: a) : Tac (matching_problem * abspat_continuation) = matching_problem_of_abs (quote abspat) (** Construct an solve a matching problem. This higher-order function isn't very usable on its own — it's mostly a convenience function to avoid duplicating the problem-parsing code. **) let match_abspat #b #a (abspat: a) (k: abspat_continuation -> Tac (matching_solution -> Tac b)) : Tac b = let goal = cur_goal () in let hypotheses = vars_of_env (cur_env ()) in let problem, continuation = interp_abspat abspat in solve_mp problem hypotheses goal (k continuation) (** Inspect the matching problem produced by parsing an abspat. **) let inspect_abspat_problem #a (abspat: a) : Tac matching_problem = fst (interp_abspat #a abspat)

abspat: a -> FStar.Tactics.Effect.Tac FStar.Tactics.PatternMatching.matching_solution

FStar.Tactics.Effect.Tac

let inspect_abspat_solution #a (abspat: a) : Tac matching_solution =

match_abspat abspat (fun _ -> (fun solution -> solution <: Tac _) <: Tac _)

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.specialize_abspat_continuation

val specialize_abspat_continuation (continuation: abspat_continuation) : Tac term

val specialize_abspat_continuation (continuation: abspat_continuation) : Tac term

let specialize_abspat_continuation (continuation: abspat_continuation) : Tac term = let solution_binder = fresh_binder (`matching_solution) in let solution_term = pack (Tv_Var (binder_to_namedv solution_binder)) in let applied = specialize_abspat_continuation' continuation solution_term in let thunked = pack (Tv_Abs solution_binder applied) in debug ("Specialized into " ^ (term_to_string thunked)); let normalized = beta_reduce thunked in debug ("… which reduces to " ^ (term_to_string normalized)); thunked

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp" let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)" /// The exception monad /// ------------------- noeq type match_res a = | Success of a | Failure of match_exception let return #a (x: a) : match_res a = Success x let (let?) (#a #b: Type) (f: match_res a) (g: a -> Tac (match_res b)) : Tac (match_res b) = match f with | Success aa -> g aa | Failure ex -> Failure ex let raise #a (ex: match_exception) : match_res a = Failure ex /// Liftings /// -------- /// /// There's a natural lifting from the exception monad into the tactic effect: let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern interpretation /// ====================== /// /// This section implement pattern-matching. This is strictly a one term, one /// pattern implementation — handling cases in which mutliple hypotheses match /// the same pattern is done later. type bindings = list (varname * term) let string_of_bindings (bindings: bindings) = String.concat "\n" (map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm)) bindings) (** Match a pattern against a term. `cur_bindings` is a list of bindings collected while matching previous parts of the pattern. Returns a result in the exception monad. **) let rec interp_pattern_aux (pat: pattern) (cur_bindings: bindings) (tm:term) : Tac (match_res bindings) = let interp_var (v: varname) cur_bindings tm = match List.Tot.Base.assoc v cur_bindings with | Some tm' -> if term_eq tm tm' then return cur_bindings else raise (NonLinearMismatch (v, tm, tm')) | None -> return ((v, tm) :: cur_bindings) in let interp_qn (qn: qn) cur_bindings tm = match inspect tm with | Tv_UInst fv _ | Tv_FVar fv -> if fv_to_string fv = qn then return cur_bindings else raise (NameMismatch (qn, (fv_to_string fv))) | _ -> raise (SimpleMismatch (pat, tm)) in let interp_type cur_bindings tm = match inspect tm with | Tv_Type _ -> return cur_bindings | _ -> raise (SimpleMismatch (pat, tm)) in let interp_app (p_hd p_arg: (p:pattern{p << pat})) cur_bindings tm = match inspect tm with | Tv_App hd (arg, _) -> let? with_hd = interp_pattern_aux p_hd cur_bindings hd in let? with_arg = interp_pattern_aux p_arg with_hd arg in return with_arg | _ -> raise (SimpleMismatch (pat, tm)) in match pat with | PVar var -> interp_var var cur_bindings tm | PQn qn -> interp_qn qn cur_bindings tm | PType -> interp_type cur_bindings tm | PApp p_hd p_arg -> interp_app p_hd p_arg cur_bindings tm (** Match a pattern `pat` against a term. Returns a result in the exception monad. **) let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) = fun (tm: term) -> let? rev_bindings = interp_pattern_aux pat [] tm in return (List.Tot.Base.rev rev_bindings) (** Match a term `tm` against a pattern `pat`. Raises an exception if the match fails. This is mostly useful for debugging: use ``mgw`` to capture matches. **) let match_term pat (tm : term) : Tac bindings = match interp_pattern pat (norm_term [] tm) with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern-matching problems /// ========================= /// /// Generalizing past single-term single-pattern problems, we obtain the /// following notions of pattern-matching problems and solutions: let debug msg : Tac unit = () // print msg /// Definitions /// ----------- let absvar = binding type hypothesis = binding /// A matching problem is composed of holes (``mp_vars``), hypothesis patterns /// (``mp_hyps``), and a goal pattern (``mp_goal``). noeq type matching_problem = { mp_vars: list varname; mp_hyps: list (varname * pattern); mp_goal: option pattern } let string_of_matching_problem mp = let vars = String.concat ", " mp.mp_vars in let hyps = String.concat "\n " (List.Tot.Base.map (fun (nm, pat) -> nm ^ ": " ^ (string_of_pattern pat)) mp.mp_hyps) in let goal = match mp.mp_goal with | None -> "_" | Some pat -> string_of_pattern pat in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ "\n" ^ " goal: " ^ goal ^ " }" /// A solution is composed of terms captured to mach the holes, and binders /// captured to match hypothesis patterns. noeq type matching_solution = { ms_vars: list (varname * term); ms_hyps: list (varname * hypothesis) } let string_of_matching_solution ms = let vars = String.concat "\n " (map (fun (varname, tm) -> varname ^ ": " ^ (term_to_string tm)) ms.ms_vars) in let hyps = String.concat "\n " (map (fun (nm, binding) -> nm ^ ": " ^ (binding_to_string binding)) ms.ms_hyps) in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ " }" (** Find a varname in an association list; fail if it can't be found. **) let assoc_varname_fail (#b: Type) (key: varname) (ls: list (varname * b)) : Tac b = match List.Tot.Base.assoc key ls with | None -> fail ("Not found: " ^ key) | Some x -> x let ms_locate_hyp (a: Type) (solution: matching_solution) (name: varname) : Tac hypothesis = assoc_varname_fail name solution.ms_hyps let ms_locate_var (a: Type) (solution: matching_solution) (name: varname) : Tac a = unquote #a (assoc_varname_fail name solution.ms_vars) let ms_locate_unit (a: Type) _solution _binder_name : Tac unit = () /// Resolution /// ---------- /// /// Solving a matching problem is a two-steps process: find an initial /// assignment for holes based on the goal pattern, then find a set of /// hypotheses matching hypothesis patterns. /// /// Note that the implementation takes a continuation of type /// ``matching_solution -> Tac a``. This continuation is needed because we want /// users to be able to provide extra criteria on matching solutions (most /// commonly, this criterion is that a particular tactic should run /// successfuly). /// /// This makes it easy to implement a simple for of search through the context, /// where one can find a hypothesis matching a particular predicate by /// constructing a trivial matching problem and passing the predicate as the /// continuation. (** Scan ``hypotheses`` for a match for ``pat`` that lets ``body`` succeed. ``name`` is used to refer to the hypothesis matched in the final solution. ``part_sol`` includes bindings gathered while matching previous solutions. **) let rec solve_mp_for_single_hyp #a (name: varname) (pat: pattern) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (part_sol: matching_solution) : Tac a = match hypotheses with | [] -> fail #a "No matching hypothesis" | h :: hs -> or_else // Must be in ``Tac`` here to run `body` (fun () -> match interp_pattern_aux pat part_sol.ms_vars (type_of_binding h) with | Failure ex -> fail ("Failed to match hyp: " ^ (string_of_match_exception ex)) | Success bindings -> let ms_hyps = (name, h) :: part_sol.ms_hyps in body ({ part_sol with ms_vars = bindings; ms_hyps = ms_hyps })) (fun () -> solve_mp_for_single_hyp name pat hs body part_sol) (** Scan ``hypotheses`` for matches for ``mp_hyps`` that lets ``body`` succeed. **) let rec solve_mp_for_hyps #a (mp_hyps: list (varname * pattern)) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (partial_solution: matching_solution) : Tac a = match mp_hyps with | [] -> body partial_solution | (name, pat) :: pats -> solve_mp_for_single_hyp name pat hypotheses (solve_mp_for_hyps pats hypotheses body) partial_solution (** Solve a matching problem. The solution returned is constructed to ensure that the continuation ``body`` succeeds: this implements the usual backtracking-match semantics. **) let solve_mp #a (problem: matching_problem) (hypotheses: list hypothesis) (goal: term) (body: matching_solution -> Tac a) : Tac a = let goal_ps = match problem.mp_goal with | None -> { ms_vars = []; ms_hyps = [] } | Some pat -> match interp_pattern pat goal with | Failure ex -> fail ("Failed to match goal: " ^ (string_of_match_exception ex)) | Success bindings -> { ms_vars = bindings; ms_hyps = [] } in solve_mp_for_hyps #a problem.mp_hyps hypotheses body goal_ps /// A DSL for pattern-matching /// ========================== /// /// Using pattern-matching problems as defined above is relatively cumbersome, /// so we now introduce a lightweight notation, in two steps: pattern notations, /// and matching-problem notations. /// /// Pattern notations /// ----------------- /// /// The first part of our pattern-matching syntax is pattern notations: we /// provide a reflective function which constructs a pattern from a term: /// variables are holes, free variables are constants, and applications are /// application patterns. (* FIXME: MOVE *) let name_of_namedv (x:namedv) : Tac string = unseal (inspect_namedv x).ppname (** Compile a term `tm` into a pattern. **) let rec pattern_of_term_ex tm : Tac (match_res pattern) = match inspect tm with | Tv_Var bv -> return (PVar (name_of_namedv bv)) | Tv_FVar fv | Tv_UInst fv _ -> let qn = fv_to_string fv in return (PQn qn) | Tv_Type _ -> return PType | Tv_App f (x, _) -> let? fpat = pattern_of_term_ex f in let? xpat = pattern_of_term_ex x in return (PApp fpat xpat) | _ -> raise (UnsupportedTermInPattern tm) (** β-reduce a term `tm`. This is useful to remove needles function applications introduced by F*, like ``(fun a b c -> a) 1 2 3``. **) let beta_reduce (tm: term) : Tac term = norm_term [] tm (** Compile a term `tm` into a pattern. **) let pattern_of_term tm : Tac pattern = match pattern_of_term_ex tm with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Problem notations /// ----------------- /// /// We then introduce a DSL for matching problems, best explained on the /// following example:: /// /// (fun (a b c: ①) (h1 h2 h3: hyp ②) (g: pm_goal ③) → ④) /// /// This notation is intended to express a pattern-matching problems with three /// holes ``a``, ``b``, and ``c`` of type ①, matching hypotheses ``h1``, ``h2``, /// and ``h3`` against pattern ② and the goal against the pattern ③. The body /// of the notation (④) is then run with appropriate terms bound to ``a``, /// ``b``, and ``c``, appropriate binders bound to ``h1``, ``h2``, and ``h3``, /// and ``()`` bound to ``g``. /// /// We call these patterns ``abspat``s (abstraction patterns), and we provide /// facilities to parse them into matching problems, and to run their bodies /// against a particular matching solution. // We used to annotate variables with an explicit 'var' marker, but then that // var annotation leaked into the types of other hypotheses due to type // inference, requiring non-trivial normalization. // let var (a: Type) = a let hyp (a: Type) = binding let pm_goal (a: Type) = unit let hyp_qn = `%hyp let goal_qn = `%pm_goal noeq type abspat_binder_kind = | ABKVar of typ | ABKHyp | ABKGoal let string_of_abspat_binder_kind = function | ABKVar _ -> "varname" | ABKHyp -> "hyp" | ABKGoal -> "goal" noeq type abspat_argspec = { asa_name: absvar; asa_kind: abspat_binder_kind } // We must store this continuation, because recomputing it yields different // names when the binders are re-opened. type abspat_continuation = list abspat_argspec * term let type_of_named_binder (nb : binder) : term = nb.sort let classify_abspat_binder (b : binder): Tac (abspat_binder_kind * term) = let varname = "v" in let hyp_pat = PApp (PQn hyp_qn) (PVar varname) in let goal_pat = PApp (PQn goal_qn) (PVar varname) in let typ = type_of_named_binder b in match interp_pattern hyp_pat typ with | Success [(_, hyp_typ)] -> ABKHyp, hyp_typ | Success _ -> fail "classifiy_abspat_binder: impossible (1)" | Failure _ -> match interp_pattern goal_pat typ with | Success [(_, goal_typ)] -> ABKGoal, goal_typ | Success _ -> fail "classifiy_abspat_binder: impossible (2)" | Failure _ -> ABKVar typ, typ (** Split an abstraction `tm` into a list of binders and a body. **) let rec binders_and_body_of_abs tm : Tac (list binder * term) = match inspect tm with | Tv_Abs binder tm -> let binders, body = binders_and_body_of_abs tm in binder :: binders, body | _ -> [], tm let cleanup_abspat (t: term) : Tac term = norm_term [] t let name_of_named_binder (nb : binder) : Tac string = unseal nb.ppname (** Parse a notation into a matching problem and a continuation. Pattern-matching notations are of the form ``(fun binders… -> continuation)``, where ``binders`` are of one of the forms ``var …``, ``hyp …``, or ``goal …``. ``var`` binders are typed holes to be used in other binders; ``hyp`` binders indicate a pattern to be matched against hypotheses; and ``goal`` binders match the goal. A reduction phase is run to ensure that the pattern looks reasonable; it is needed because F* tends to infer arguments in β-expanded form. The continuation returned can't directly be applied to a pattern-matching solution; see ``interp_abspat_continuation`` below for that. **) let matching_problem_of_abs (tm: term) : Tac (matching_problem * abspat_continuation) = let binders, body = binders_and_body_of_abs (cleanup_abspat tm) in debug ("Got binders: " ^ (String.concat ", " (map (fun b -> name_of_named_binder b <: Tac string) binders))); let classified_binders : list (binder & string & abspat_binder_kind & typ) = map (fun binder -> let bv_name = name_of_named_binder binder in debug ("Got binder: " ^ bv_name ^ "; type is " ^ term_to_string (type_of_named_binder binder)); let binder_kind, typ = classify_abspat_binder binder in (binder, bv_name, binder_kind, typ)) binders in let problem = fold_left (fun problem (binder, bv_name, binder_kind, typ) -> debug ("Compiling binder " ^ name_of_named_binder binder ^ ", classified as " ^ string_of_abspat_binder_kind binder_kind ^ ", with type " ^ term_to_string typ); match binder_kind with | ABKVar _ -> { problem with mp_vars = bv_name :: problem.mp_vars } | ABKHyp -> { problem with mp_hyps = (bv_name, (pattern_of_term typ)) :: problem.mp_hyps } | ABKGoal -> { problem with mp_goal = Some (pattern_of_term typ) }) ({ mp_vars = []; mp_hyps = []; mp_goal = None }) classified_binders in let continuation = let abspat_argspec_of_binder xx : Tac abspat_argspec = match xx with | (binder, xx, binder_kind, yy) -> { asa_name = binder_to_binding binder; asa_kind = binder_kind } in (map abspat_argspec_of_binder classified_binders, tm) in let mp = { mp_vars = List.Tot.Base.rev #varname problem.mp_vars; mp_hyps = List.Tot.Base.rev #(varname * pattern) problem.mp_hyps; mp_goal = problem.mp_goal } in debug ("Got matching problem: " ^ (string_of_matching_problem mp)); mp, continuation /// Continuations /// ------------- /// /// Parsing an abspat yields a matching problem and a continuation of type /// ``abspat_continuation``, which is essentially just a list of binders and a /// term (the body of the abstraction pattern). (** Get the (quoted) type expected by a specific kind of abspat binder. **) let arg_type_of_binder_kind binder_kind : Tac term = match binder_kind with | ABKVar typ -> typ | ABKHyp -> `binder | ABKGoal -> `unit (** Retrieve the function used to locate a value for a given abspat binder. **) let locate_fn_of_binder_kind binder_kind = match binder_kind with | ABKVar _ -> `ms_locate_var | ABKHyp -> `ms_locate_hyp | ABKGoal -> `ms_locate_unit (** Construct a term fetching the value of an abspat argument from a quoted matching solution ``solution_term``. **) let abspat_arg_of_abspat_argspec solution_term (argspec: abspat_argspec) : Tac term = let loc_fn = locate_fn_of_binder_kind argspec.asa_kind in let name_tm = pack (Tv_Const (C_String (unseal argspec.asa_name.ppname))) in let locate_args = [(arg_type_of_binder_kind argspec.asa_kind, Q_Explicit); (solution_term, Q_Explicit); (name_tm, Q_Explicit)] in mk_app loc_fn locate_args (** Specialize a continuation of type ``abspat_continuation``. This constructs a fully applied version of `continuation`, but it requires a quoted solution to be passed in. **) let rec hoist_and_apply (head:term) (arg_terms:list term) (hoisted_args:list argv) : Tac term = match arg_terms with | [] -> mk_app head (List.rev hoisted_args) | arg_term::rest -> let n = List.Tot.length hoisted_args in //let bv = fresh_bv_named ("x" ^ (string_of_int n)) in let nb : binder = { ppname = seal ("x" ^ string_of_int n); sort = pack Tv_Unknown; uniq = fresh (); qual = Q_Explicit; attrs = [] ; } in pack (Tv_Let false [] nb arg_term (hoist_and_apply head rest ((pack (Tv_Var (binder_to_namedv nb)), Q_Explicit)::hoisted_args))) let specialize_abspat_continuation' (continuation: abspat_continuation) (solution_term:term) : Tac term = let mk_arg_term argspec = abspat_arg_of_abspat_argspec solution_term argspec in let argspecs, body = continuation in hoist_and_apply body (map mk_arg_term argspecs) [] (** Specialize a continuation of type ``abspat_continuation``. This yields a quoted function taking a matching solution and running its body with appropriate

continuation: FStar.Tactics.PatternMatching.abspat_continuation -> FStar.Tactics.Effect.Tac FStar.Tactics.NamedView.term

FStar.Tactics.Effect.Tac

let specialize_abspat_continuation (continuation: abspat_continuation) : Tac term =

let solution_binder = fresh_binder (`matching_solution) in let solution_term = pack (Tv_Var (binder_to_namedv solution_binder)) in let applied = specialize_abspat_continuation' continuation solution_term in let thunked = pack (Tv_Abs solution_binder applied) in debug ("Specialized into " ^ (term_to_string thunked)); let normalized = beta_reduce thunked in debug ("\226\128\166 which reduces to " ^ (term_to_string normalized)); thunked

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.desc_of_pattern

val desc_of_pattern : _: FStar.Tactics.PatternMatching.pattern -> Prims.string

let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application"

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern

_: FStar.Tactics.PatternMatching.pattern -> Prims.string

Prims.Tot

let desc_of_pattern =

function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application"

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.inspect_abspat_problem

val inspect_abspat_problem (#a: _) (abspat: a) : Tac matching_problem

val inspect_abspat_problem (#a: _) (abspat: a) : Tac matching_problem

let inspect_abspat_problem #a (abspat: a) : Tac matching_problem = fst (interp_abspat #a abspat)

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp" let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)" /// The exception monad /// ------------------- noeq type match_res a = | Success of a | Failure of match_exception let return #a (x: a) : match_res a = Success x let (let?) (#a #b: Type) (f: match_res a) (g: a -> Tac (match_res b)) : Tac (match_res b) = match f with | Success aa -> g aa | Failure ex -> Failure ex let raise #a (ex: match_exception) : match_res a = Failure ex /// Liftings /// -------- /// /// There's a natural lifting from the exception monad into the tactic effect: let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern interpretation /// ====================== /// /// This section implement pattern-matching. This is strictly a one term, one /// pattern implementation — handling cases in which mutliple hypotheses match /// the same pattern is done later. type bindings = list (varname * term) let string_of_bindings (bindings: bindings) = String.concat "\n" (map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm)) bindings) (** Match a pattern against a term. `cur_bindings` is a list of bindings collected while matching previous parts of the pattern. Returns a result in the exception monad. **) let rec interp_pattern_aux (pat: pattern) (cur_bindings: bindings) (tm:term) : Tac (match_res bindings) = let interp_var (v: varname) cur_bindings tm = match List.Tot.Base.assoc v cur_bindings with | Some tm' -> if term_eq tm tm' then return cur_bindings else raise (NonLinearMismatch (v, tm, tm')) | None -> return ((v, tm) :: cur_bindings) in let interp_qn (qn: qn) cur_bindings tm = match inspect tm with | Tv_UInst fv _ | Tv_FVar fv -> if fv_to_string fv = qn then return cur_bindings else raise (NameMismatch (qn, (fv_to_string fv))) | _ -> raise (SimpleMismatch (pat, tm)) in let interp_type cur_bindings tm = match inspect tm with | Tv_Type _ -> return cur_bindings | _ -> raise (SimpleMismatch (pat, tm)) in let interp_app (p_hd p_arg: (p:pattern{p << pat})) cur_bindings tm = match inspect tm with | Tv_App hd (arg, _) -> let? with_hd = interp_pattern_aux p_hd cur_bindings hd in let? with_arg = interp_pattern_aux p_arg with_hd arg in return with_arg | _ -> raise (SimpleMismatch (pat, tm)) in match pat with | PVar var -> interp_var var cur_bindings tm | PQn qn -> interp_qn qn cur_bindings tm | PType -> interp_type cur_bindings tm | PApp p_hd p_arg -> interp_app p_hd p_arg cur_bindings tm (** Match a pattern `pat` against a term. Returns a result in the exception monad. **) let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) = fun (tm: term) -> let? rev_bindings = interp_pattern_aux pat [] tm in return (List.Tot.Base.rev rev_bindings) (** Match a term `tm` against a pattern `pat`. Raises an exception if the match fails. This is mostly useful for debugging: use ``mgw`` to capture matches. **) let match_term pat (tm : term) : Tac bindings = match interp_pattern pat (norm_term [] tm) with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern-matching problems /// ========================= /// /// Generalizing past single-term single-pattern problems, we obtain the /// following notions of pattern-matching problems and solutions: let debug msg : Tac unit = () // print msg /// Definitions /// ----------- let absvar = binding type hypothesis = binding /// A matching problem is composed of holes (``mp_vars``), hypothesis patterns /// (``mp_hyps``), and a goal pattern (``mp_goal``). noeq type matching_problem = { mp_vars: list varname; mp_hyps: list (varname * pattern); mp_goal: option pattern } let string_of_matching_problem mp = let vars = String.concat ", " mp.mp_vars in let hyps = String.concat "\n " (List.Tot.Base.map (fun (nm, pat) -> nm ^ ": " ^ (string_of_pattern pat)) mp.mp_hyps) in let goal = match mp.mp_goal with | None -> "_" | Some pat -> string_of_pattern pat in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ "\n" ^ " goal: " ^ goal ^ " }" /// A solution is composed of terms captured to mach the holes, and binders /// captured to match hypothesis patterns. noeq type matching_solution = { ms_vars: list (varname * term); ms_hyps: list (varname * hypothesis) } let string_of_matching_solution ms = let vars = String.concat "\n " (map (fun (varname, tm) -> varname ^ ": " ^ (term_to_string tm)) ms.ms_vars) in let hyps = String.concat "\n " (map (fun (nm, binding) -> nm ^ ": " ^ (binding_to_string binding)) ms.ms_hyps) in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ " }" (** Find a varname in an association list; fail if it can't be found. **) let assoc_varname_fail (#b: Type) (key: varname) (ls: list (varname * b)) : Tac b = match List.Tot.Base.assoc key ls with | None -> fail ("Not found: " ^ key) | Some x -> x let ms_locate_hyp (a: Type) (solution: matching_solution) (name: varname) : Tac hypothesis = assoc_varname_fail name solution.ms_hyps let ms_locate_var (a: Type) (solution: matching_solution) (name: varname) : Tac a = unquote #a (assoc_varname_fail name solution.ms_vars) let ms_locate_unit (a: Type) _solution _binder_name : Tac unit = () /// Resolution /// ---------- /// /// Solving a matching problem is a two-steps process: find an initial /// assignment for holes based on the goal pattern, then find a set of /// hypotheses matching hypothesis patterns. /// /// Note that the implementation takes a continuation of type /// ``matching_solution -> Tac a``. This continuation is needed because we want /// users to be able to provide extra criteria on matching solutions (most /// commonly, this criterion is that a particular tactic should run /// successfuly). /// /// This makes it easy to implement a simple for of search through the context, /// where one can find a hypothesis matching a particular predicate by /// constructing a trivial matching problem and passing the predicate as the /// continuation. (** Scan ``hypotheses`` for a match for ``pat`` that lets ``body`` succeed. ``name`` is used to refer to the hypothesis matched in the final solution. ``part_sol`` includes bindings gathered while matching previous solutions. **) let rec solve_mp_for_single_hyp #a (name: varname) (pat: pattern) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (part_sol: matching_solution) : Tac a = match hypotheses with | [] -> fail #a "No matching hypothesis" | h :: hs -> or_else // Must be in ``Tac`` here to run `body` (fun () -> match interp_pattern_aux pat part_sol.ms_vars (type_of_binding h) with | Failure ex -> fail ("Failed to match hyp: " ^ (string_of_match_exception ex)) | Success bindings -> let ms_hyps = (name, h) :: part_sol.ms_hyps in body ({ part_sol with ms_vars = bindings; ms_hyps = ms_hyps })) (fun () -> solve_mp_for_single_hyp name pat hs body part_sol) (** Scan ``hypotheses`` for matches for ``mp_hyps`` that lets ``body`` succeed. **) let rec solve_mp_for_hyps #a (mp_hyps: list (varname * pattern)) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (partial_solution: matching_solution) : Tac a = match mp_hyps with | [] -> body partial_solution | (name, pat) :: pats -> solve_mp_for_single_hyp name pat hypotheses (solve_mp_for_hyps pats hypotheses body) partial_solution (** Solve a matching problem. The solution returned is constructed to ensure that the continuation ``body`` succeeds: this implements the usual backtracking-match semantics. **) let solve_mp #a (problem: matching_problem) (hypotheses: list hypothesis) (goal: term) (body: matching_solution -> Tac a) : Tac a = let goal_ps = match problem.mp_goal with | None -> { ms_vars = []; ms_hyps = [] } | Some pat -> match interp_pattern pat goal with | Failure ex -> fail ("Failed to match goal: " ^ (string_of_match_exception ex)) | Success bindings -> { ms_vars = bindings; ms_hyps = [] } in solve_mp_for_hyps #a problem.mp_hyps hypotheses body goal_ps /// A DSL for pattern-matching /// ========================== /// /// Using pattern-matching problems as defined above is relatively cumbersome, /// so we now introduce a lightweight notation, in two steps: pattern notations, /// and matching-problem notations. /// /// Pattern notations /// ----------------- /// /// The first part of our pattern-matching syntax is pattern notations: we /// provide a reflective function which constructs a pattern from a term: /// variables are holes, free variables are constants, and applications are /// application patterns. (* FIXME: MOVE *) let name_of_namedv (x:namedv) : Tac string = unseal (inspect_namedv x).ppname (** Compile a term `tm` into a pattern. **) let rec pattern_of_term_ex tm : Tac (match_res pattern) = match inspect tm with | Tv_Var bv -> return (PVar (name_of_namedv bv)) | Tv_FVar fv | Tv_UInst fv _ -> let qn = fv_to_string fv in return (PQn qn) | Tv_Type _ -> return PType | Tv_App f (x, _) -> let? fpat = pattern_of_term_ex f in let? xpat = pattern_of_term_ex x in return (PApp fpat xpat) | _ -> raise (UnsupportedTermInPattern tm) (** β-reduce a term `tm`. This is useful to remove needles function applications introduced by F*, like ``(fun a b c -> a) 1 2 3``. **) let beta_reduce (tm: term) : Tac term = norm_term [] tm (** Compile a term `tm` into a pattern. **) let pattern_of_term tm : Tac pattern = match pattern_of_term_ex tm with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Problem notations /// ----------------- /// /// We then introduce a DSL for matching problems, best explained on the /// following example:: /// /// (fun (a b c: ①) (h1 h2 h3: hyp ②) (g: pm_goal ③) → ④) /// /// This notation is intended to express a pattern-matching problems with three /// holes ``a``, ``b``, and ``c`` of type ①, matching hypotheses ``h1``, ``h2``, /// and ``h3`` against pattern ② and the goal against the pattern ③. The body /// of the notation (④) is then run with appropriate terms bound to ``a``, /// ``b``, and ``c``, appropriate binders bound to ``h1``, ``h2``, and ``h3``, /// and ``()`` bound to ``g``. /// /// We call these patterns ``abspat``s (abstraction patterns), and we provide /// facilities to parse them into matching problems, and to run their bodies /// against a particular matching solution. // We used to annotate variables with an explicit 'var' marker, but then that // var annotation leaked into the types of other hypotheses due to type // inference, requiring non-trivial normalization. // let var (a: Type) = a let hyp (a: Type) = binding let pm_goal (a: Type) = unit let hyp_qn = `%hyp let goal_qn = `%pm_goal noeq type abspat_binder_kind = | ABKVar of typ | ABKHyp | ABKGoal let string_of_abspat_binder_kind = function | ABKVar _ -> "varname" | ABKHyp -> "hyp" | ABKGoal -> "goal" noeq type abspat_argspec = { asa_name: absvar; asa_kind: abspat_binder_kind } // We must store this continuation, because recomputing it yields different // names when the binders are re-opened. type abspat_continuation = list abspat_argspec * term let type_of_named_binder (nb : binder) : term = nb.sort let classify_abspat_binder (b : binder): Tac (abspat_binder_kind * term) = let varname = "v" in let hyp_pat = PApp (PQn hyp_qn) (PVar varname) in let goal_pat = PApp (PQn goal_qn) (PVar varname) in let typ = type_of_named_binder b in match interp_pattern hyp_pat typ with | Success [(_, hyp_typ)] -> ABKHyp, hyp_typ | Success _ -> fail "classifiy_abspat_binder: impossible (1)" | Failure _ -> match interp_pattern goal_pat typ with | Success [(_, goal_typ)] -> ABKGoal, goal_typ | Success _ -> fail "classifiy_abspat_binder: impossible (2)" | Failure _ -> ABKVar typ, typ (** Split an abstraction `tm` into a list of binders and a body. **) let rec binders_and_body_of_abs tm : Tac (list binder * term) = match inspect tm with | Tv_Abs binder tm -> let binders, body = binders_and_body_of_abs tm in binder :: binders, body | _ -> [], tm let cleanup_abspat (t: term) : Tac term = norm_term [] t let name_of_named_binder (nb : binder) : Tac string = unseal nb.ppname (** Parse a notation into a matching problem and a continuation. Pattern-matching notations are of the form ``(fun binders… -> continuation)``, where ``binders`` are of one of the forms ``var …``, ``hyp …``, or ``goal …``. ``var`` binders are typed holes to be used in other binders; ``hyp`` binders indicate a pattern to be matched against hypotheses; and ``goal`` binders match the goal. A reduction phase is run to ensure that the pattern looks reasonable; it is needed because F* tends to infer arguments in β-expanded form. The continuation returned can't directly be applied to a pattern-matching solution; see ``interp_abspat_continuation`` below for that. **) let matching_problem_of_abs (tm: term) : Tac (matching_problem * abspat_continuation) = let binders, body = binders_and_body_of_abs (cleanup_abspat tm) in debug ("Got binders: " ^ (String.concat ", " (map (fun b -> name_of_named_binder b <: Tac string) binders))); let classified_binders : list (binder & string & abspat_binder_kind & typ) = map (fun binder -> let bv_name = name_of_named_binder binder in debug ("Got binder: " ^ bv_name ^ "; type is " ^ term_to_string (type_of_named_binder binder)); let binder_kind, typ = classify_abspat_binder binder in (binder, bv_name, binder_kind, typ)) binders in let problem = fold_left (fun problem (binder, bv_name, binder_kind, typ) -> debug ("Compiling binder " ^ name_of_named_binder binder ^ ", classified as " ^ string_of_abspat_binder_kind binder_kind ^ ", with type " ^ term_to_string typ); match binder_kind with | ABKVar _ -> { problem with mp_vars = bv_name :: problem.mp_vars } | ABKHyp -> { problem with mp_hyps = (bv_name, (pattern_of_term typ)) :: problem.mp_hyps } | ABKGoal -> { problem with mp_goal = Some (pattern_of_term typ) }) ({ mp_vars = []; mp_hyps = []; mp_goal = None }) classified_binders in let continuation = let abspat_argspec_of_binder xx : Tac abspat_argspec = match xx with | (binder, xx, binder_kind, yy) -> { asa_name = binder_to_binding binder; asa_kind = binder_kind } in (map abspat_argspec_of_binder classified_binders, tm) in let mp = { mp_vars = List.Tot.Base.rev #varname problem.mp_vars; mp_hyps = List.Tot.Base.rev #(varname * pattern) problem.mp_hyps; mp_goal = problem.mp_goal } in debug ("Got matching problem: " ^ (string_of_matching_problem mp)); mp, continuation /// Continuations /// ------------- /// /// Parsing an abspat yields a matching problem and a continuation of type /// ``abspat_continuation``, which is essentially just a list of binders and a /// term (the body of the abstraction pattern). (** Get the (quoted) type expected by a specific kind of abspat binder. **) let arg_type_of_binder_kind binder_kind : Tac term = match binder_kind with | ABKVar typ -> typ | ABKHyp -> `binder | ABKGoal -> `unit (** Retrieve the function used to locate a value for a given abspat binder. **) let locate_fn_of_binder_kind binder_kind = match binder_kind with | ABKVar _ -> `ms_locate_var | ABKHyp -> `ms_locate_hyp | ABKGoal -> `ms_locate_unit (** Construct a term fetching the value of an abspat argument from a quoted matching solution ``solution_term``. **) let abspat_arg_of_abspat_argspec solution_term (argspec: abspat_argspec) : Tac term = let loc_fn = locate_fn_of_binder_kind argspec.asa_kind in let name_tm = pack (Tv_Const (C_String (unseal argspec.asa_name.ppname))) in let locate_args = [(arg_type_of_binder_kind argspec.asa_kind, Q_Explicit); (solution_term, Q_Explicit); (name_tm, Q_Explicit)] in mk_app loc_fn locate_args (** Specialize a continuation of type ``abspat_continuation``. This constructs a fully applied version of `continuation`, but it requires a quoted solution to be passed in. **) let rec hoist_and_apply (head:term) (arg_terms:list term) (hoisted_args:list argv) : Tac term = match arg_terms with | [] -> mk_app head (List.rev hoisted_args) | arg_term::rest -> let n = List.Tot.length hoisted_args in //let bv = fresh_bv_named ("x" ^ (string_of_int n)) in let nb : binder = { ppname = seal ("x" ^ string_of_int n); sort = pack Tv_Unknown; uniq = fresh (); qual = Q_Explicit; attrs = [] ; } in pack (Tv_Let false [] nb arg_term (hoist_and_apply head rest ((pack (Tv_Var (binder_to_namedv nb)), Q_Explicit)::hoisted_args))) let specialize_abspat_continuation' (continuation: abspat_continuation) (solution_term:term) : Tac term = let mk_arg_term argspec = abspat_arg_of_abspat_argspec solution_term argspec in let argspecs, body = continuation in hoist_and_apply body (map mk_arg_term argspecs) [] (** Specialize a continuation of type ``abspat_continuation``. This yields a quoted function taking a matching solution and running its body with appropriate bindings. **) let specialize_abspat_continuation (continuation: abspat_continuation) : Tac term = let solution_binder = fresh_binder (`matching_solution) in let solution_term = pack (Tv_Var (binder_to_namedv solution_binder)) in let applied = specialize_abspat_continuation' continuation solution_term in let thunked = pack (Tv_Abs solution_binder applied) in debug ("Specialized into " ^ (term_to_string thunked)); let normalized = beta_reduce thunked in debug ("… which reduces to " ^ (term_to_string normalized)); thunked (** Interpret a continuation of type ``abspat_continuation``. This yields a function taking a matching solution and running the body of the continuation with appropriate bindings. **) let interp_abspat_continuation (a:Type0) (continuation: abspat_continuation) : Tac (matching_solution -> Tac a) = let applied = specialize_abspat_continuation continuation in unquote #(matching_solution -> Tac a) applied /// Putting it all together /// ======================= /// /// We now have all we need to use pattern-matching, short of a few convenience functions: (** Construct a matching problem from an abspat. **) let interp_abspat #a (abspat: a) : Tac (matching_problem * abspat_continuation) = matching_problem_of_abs (quote abspat) (** Construct an solve a matching problem. This higher-order function isn't very usable on its own — it's mostly a convenience function to avoid duplicating the problem-parsing code. **) let match_abspat #b #a (abspat: a) (k: abspat_continuation -> Tac (matching_solution -> Tac b)) : Tac b = let goal = cur_goal () in let hypotheses = vars_of_env (cur_env ()) in let problem, continuation = interp_abspat abspat in solve_mp problem hypotheses goal (k continuation)

abspat: a -> FStar.Tactics.Effect.Tac FStar.Tactics.PatternMatching.matching_problem

FStar.Tactics.Effect.Tac

let inspect_abspat_problem #a (abspat: a) : Tac matching_problem =

fst (interp_abspat #a abspat)

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.tpair

val tpair (#a #b: _) (x: a) : Tac (b -> Tac (a * b))

val tpair (#a #b: _) (x: a) : Tac (b -> Tac (a * b))

let tpair #a #b (x : a) : Tac (b -> Tac (a * b)) = fun (y: b) -> (x, y)

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp" let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)" /// The exception monad /// ------------------- noeq type match_res a = | Success of a | Failure of match_exception let return #a (x: a) : match_res a = Success x let (let?) (#a #b: Type) (f: match_res a) (g: a -> Tac (match_res b)) : Tac (match_res b) = match f with | Success aa -> g aa | Failure ex -> Failure ex let raise #a (ex: match_exception) : match_res a = Failure ex /// Liftings /// -------- /// /// There's a natural lifting from the exception monad into the tactic effect: let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern interpretation /// ====================== /// /// This section implement pattern-matching. This is strictly a one term, one /// pattern implementation — handling cases in which mutliple hypotheses match /// the same pattern is done later. type bindings = list (varname * term) let string_of_bindings (bindings: bindings) = String.concat "\n" (map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm)) bindings) (** Match a pattern against a term. `cur_bindings` is a list of bindings collected while matching previous parts of the pattern. Returns a result in the exception monad. **) let rec interp_pattern_aux (pat: pattern) (cur_bindings: bindings) (tm:term) : Tac (match_res bindings) = let interp_var (v: varname) cur_bindings tm = match List.Tot.Base.assoc v cur_bindings with | Some tm' -> if term_eq tm tm' then return cur_bindings else raise (NonLinearMismatch (v, tm, tm')) | None -> return ((v, tm) :: cur_bindings) in let interp_qn (qn: qn) cur_bindings tm = match inspect tm with | Tv_UInst fv _ | Tv_FVar fv -> if fv_to_string fv = qn then return cur_bindings else raise (NameMismatch (qn, (fv_to_string fv))) | _ -> raise (SimpleMismatch (pat, tm)) in let interp_type cur_bindings tm = match inspect tm with | Tv_Type _ -> return cur_bindings | _ -> raise (SimpleMismatch (pat, tm)) in let interp_app (p_hd p_arg: (p:pattern{p << pat})) cur_bindings tm = match inspect tm with | Tv_App hd (arg, _) -> let? with_hd = interp_pattern_aux p_hd cur_bindings hd in let? with_arg = interp_pattern_aux p_arg with_hd arg in return with_arg | _ -> raise (SimpleMismatch (pat, tm)) in match pat with | PVar var -> interp_var var cur_bindings tm | PQn qn -> interp_qn qn cur_bindings tm | PType -> interp_type cur_bindings tm | PApp p_hd p_arg -> interp_app p_hd p_arg cur_bindings tm (** Match a pattern `pat` against a term. Returns a result in the exception monad. **) let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) = fun (tm: term) -> let? rev_bindings = interp_pattern_aux pat [] tm in return (List.Tot.Base.rev rev_bindings) (** Match a term `tm` against a pattern `pat`. Raises an exception if the match fails. This is mostly useful for debugging: use ``mgw`` to capture matches. **) let match_term pat (tm : term) : Tac bindings = match interp_pattern pat (norm_term [] tm) with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern-matching problems /// ========================= /// /// Generalizing past single-term single-pattern problems, we obtain the /// following notions of pattern-matching problems and solutions: let debug msg : Tac unit = () // print msg /// Definitions /// ----------- let absvar = binding type hypothesis = binding /// A matching problem is composed of holes (``mp_vars``), hypothesis patterns /// (``mp_hyps``), and a goal pattern (``mp_goal``). noeq type matching_problem = { mp_vars: list varname; mp_hyps: list (varname * pattern); mp_goal: option pattern } let string_of_matching_problem mp = let vars = String.concat ", " mp.mp_vars in let hyps = String.concat "\n " (List.Tot.Base.map (fun (nm, pat) -> nm ^ ": " ^ (string_of_pattern pat)) mp.mp_hyps) in let goal = match mp.mp_goal with | None -> "_" | Some pat -> string_of_pattern pat in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ "\n" ^ " goal: " ^ goal ^ " }" /// A solution is composed of terms captured to mach the holes, and binders /// captured to match hypothesis patterns. noeq type matching_solution = { ms_vars: list (varname * term); ms_hyps: list (varname * hypothesis) } let string_of_matching_solution ms = let vars = String.concat "\n " (map (fun (varname, tm) -> varname ^ ": " ^ (term_to_string tm)) ms.ms_vars) in let hyps = String.concat "\n " (map (fun (nm, binding) -> nm ^ ": " ^ (binding_to_string binding)) ms.ms_hyps) in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ " }" (** Find a varname in an association list; fail if it can't be found. **) let assoc_varname_fail (#b: Type) (key: varname) (ls: list (varname * b)) : Tac b = match List.Tot.Base.assoc key ls with | None -> fail ("Not found: " ^ key) | Some x -> x let ms_locate_hyp (a: Type) (solution: matching_solution) (name: varname) : Tac hypothesis = assoc_varname_fail name solution.ms_hyps let ms_locate_var (a: Type) (solution: matching_solution) (name: varname) : Tac a = unquote #a (assoc_varname_fail name solution.ms_vars) let ms_locate_unit (a: Type) _solution _binder_name : Tac unit = () /// Resolution /// ---------- /// /// Solving a matching problem is a two-steps process: find an initial /// assignment for holes based on the goal pattern, then find a set of /// hypotheses matching hypothesis patterns. /// /// Note that the implementation takes a continuation of type /// ``matching_solution -> Tac a``. This continuation is needed because we want /// users to be able to provide extra criteria on matching solutions (most /// commonly, this criterion is that a particular tactic should run /// successfuly). /// /// This makes it easy to implement a simple for of search through the context, /// where one can find a hypothesis matching a particular predicate by /// constructing a trivial matching problem and passing the predicate as the /// continuation. (** Scan ``hypotheses`` for a match for ``pat`` that lets ``body`` succeed. ``name`` is used to refer to the hypothesis matched in the final solution. ``part_sol`` includes bindings gathered while matching previous solutions. **) let rec solve_mp_for_single_hyp #a (name: varname) (pat: pattern) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (part_sol: matching_solution) : Tac a = match hypotheses with | [] -> fail #a "No matching hypothesis" | h :: hs -> or_else // Must be in ``Tac`` here to run `body` (fun () -> match interp_pattern_aux pat part_sol.ms_vars (type_of_binding h) with | Failure ex -> fail ("Failed to match hyp: " ^ (string_of_match_exception ex)) | Success bindings -> let ms_hyps = (name, h) :: part_sol.ms_hyps in body ({ part_sol with ms_vars = bindings; ms_hyps = ms_hyps })) (fun () -> solve_mp_for_single_hyp name pat hs body part_sol) (** Scan ``hypotheses`` for matches for ``mp_hyps`` that lets ``body`` succeed. **) let rec solve_mp_for_hyps #a (mp_hyps: list (varname * pattern)) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (partial_solution: matching_solution) : Tac a = match mp_hyps with | [] -> body partial_solution | (name, pat) :: pats -> solve_mp_for_single_hyp name pat hypotheses (solve_mp_for_hyps pats hypotheses body) partial_solution (** Solve a matching problem. The solution returned is constructed to ensure that the continuation ``body`` succeeds: this implements the usual backtracking-match semantics. **) let solve_mp #a (problem: matching_problem) (hypotheses: list hypothesis) (goal: term) (body: matching_solution -> Tac a) : Tac a = let goal_ps = match problem.mp_goal with | None -> { ms_vars = []; ms_hyps = [] } | Some pat -> match interp_pattern pat goal with | Failure ex -> fail ("Failed to match goal: " ^ (string_of_match_exception ex)) | Success bindings -> { ms_vars = bindings; ms_hyps = [] } in solve_mp_for_hyps #a problem.mp_hyps hypotheses body goal_ps /// A DSL for pattern-matching /// ========================== /// /// Using pattern-matching problems as defined above is relatively cumbersome, /// so we now introduce a lightweight notation, in two steps: pattern notations, /// and matching-problem notations. /// /// Pattern notations /// ----------------- /// /// The first part of our pattern-matching syntax is pattern notations: we /// provide a reflective function which constructs a pattern from a term: /// variables are holes, free variables are constants, and applications are /// application patterns. (* FIXME: MOVE *) let name_of_namedv (x:namedv) : Tac string = unseal (inspect_namedv x).ppname (** Compile a term `tm` into a pattern. **) let rec pattern_of_term_ex tm : Tac (match_res pattern) = match inspect tm with | Tv_Var bv -> return (PVar (name_of_namedv bv)) | Tv_FVar fv | Tv_UInst fv _ -> let qn = fv_to_string fv in return (PQn qn) | Tv_Type _ -> return PType | Tv_App f (x, _) -> let? fpat = pattern_of_term_ex f in let? xpat = pattern_of_term_ex x in return (PApp fpat xpat) | _ -> raise (UnsupportedTermInPattern tm) (** β-reduce a term `tm`. This is useful to remove needles function applications introduced by F*, like ``(fun a b c -> a) 1 2 3``. **) let beta_reduce (tm: term) : Tac term = norm_term [] tm (** Compile a term `tm` into a pattern. **) let pattern_of_term tm : Tac pattern = match pattern_of_term_ex tm with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Problem notations /// ----------------- /// /// We then introduce a DSL for matching problems, best explained on the /// following example:: /// /// (fun (a b c: ①) (h1 h2 h3: hyp ②) (g: pm_goal ③) → ④) /// /// This notation is intended to express a pattern-matching problems with three /// holes ``a``, ``b``, and ``c`` of type ①, matching hypotheses ``h1``, ``h2``, /// and ``h3`` against pattern ② and the goal against the pattern ③. The body /// of the notation (④) is then run with appropriate terms bound to ``a``, /// ``b``, and ``c``, appropriate binders bound to ``h1``, ``h2``, and ``h3``, /// and ``()`` bound to ``g``. /// /// We call these patterns ``abspat``s (abstraction patterns), and we provide /// facilities to parse them into matching problems, and to run their bodies /// against a particular matching solution. // We used to annotate variables with an explicit 'var' marker, but then that // var annotation leaked into the types of other hypotheses due to type // inference, requiring non-trivial normalization. // let var (a: Type) = a let hyp (a: Type) = binding let pm_goal (a: Type) = unit let hyp_qn = `%hyp let goal_qn = `%pm_goal noeq type abspat_binder_kind = | ABKVar of typ | ABKHyp | ABKGoal let string_of_abspat_binder_kind = function | ABKVar _ -> "varname" | ABKHyp -> "hyp" | ABKGoal -> "goal" noeq type abspat_argspec = { asa_name: absvar; asa_kind: abspat_binder_kind } // We must store this continuation, because recomputing it yields different // names when the binders are re-opened. type abspat_continuation = list abspat_argspec * term let type_of_named_binder (nb : binder) : term = nb.sort let classify_abspat_binder (b : binder): Tac (abspat_binder_kind * term) = let varname = "v" in let hyp_pat = PApp (PQn hyp_qn) (PVar varname) in let goal_pat = PApp (PQn goal_qn) (PVar varname) in let typ = type_of_named_binder b in match interp_pattern hyp_pat typ with | Success [(_, hyp_typ)] -> ABKHyp, hyp_typ | Success _ -> fail "classifiy_abspat_binder: impossible (1)" | Failure _ -> match interp_pattern goal_pat typ with | Success [(_, goal_typ)] -> ABKGoal, goal_typ | Success _ -> fail "classifiy_abspat_binder: impossible (2)" | Failure _ -> ABKVar typ, typ (** Split an abstraction `tm` into a list of binders and a body. **) let rec binders_and_body_of_abs tm : Tac (list binder * term) = match inspect tm with | Tv_Abs binder tm -> let binders, body = binders_and_body_of_abs tm in binder :: binders, body | _ -> [], tm let cleanup_abspat (t: term) : Tac term = norm_term [] t let name_of_named_binder (nb : binder) : Tac string = unseal nb.ppname (** Parse a notation into a matching problem and a continuation. Pattern-matching notations are of the form ``(fun binders… -> continuation)``, where ``binders`` are of one of the forms ``var …``, ``hyp …``, or ``goal …``. ``var`` binders are typed holes to be used in other binders; ``hyp`` binders indicate a pattern to be matched against hypotheses; and ``goal`` binders match the goal. A reduction phase is run to ensure that the pattern looks reasonable; it is needed because F* tends to infer arguments in β-expanded form. The continuation returned can't directly be applied to a pattern-matching solution; see ``interp_abspat_continuation`` below for that. **) let matching_problem_of_abs (tm: term) : Tac (matching_problem * abspat_continuation) = let binders, body = binders_and_body_of_abs (cleanup_abspat tm) in debug ("Got binders: " ^ (String.concat ", " (map (fun b -> name_of_named_binder b <: Tac string) binders))); let classified_binders : list (binder & string & abspat_binder_kind & typ) = map (fun binder -> let bv_name = name_of_named_binder binder in debug ("Got binder: " ^ bv_name ^ "; type is " ^ term_to_string (type_of_named_binder binder)); let binder_kind, typ = classify_abspat_binder binder in (binder, bv_name, binder_kind, typ)) binders in let problem = fold_left (fun problem (binder, bv_name, binder_kind, typ) -> debug ("Compiling binder " ^ name_of_named_binder binder ^ ", classified as " ^ string_of_abspat_binder_kind binder_kind ^ ", with type " ^ term_to_string typ); match binder_kind with | ABKVar _ -> { problem with mp_vars = bv_name :: problem.mp_vars } | ABKHyp -> { problem with mp_hyps = (bv_name, (pattern_of_term typ)) :: problem.mp_hyps } | ABKGoal -> { problem with mp_goal = Some (pattern_of_term typ) }) ({ mp_vars = []; mp_hyps = []; mp_goal = None }) classified_binders in let continuation = let abspat_argspec_of_binder xx : Tac abspat_argspec = match xx with | (binder, xx, binder_kind, yy) -> { asa_name = binder_to_binding binder; asa_kind = binder_kind } in (map abspat_argspec_of_binder classified_binders, tm) in let mp = { mp_vars = List.Tot.Base.rev #varname problem.mp_vars; mp_hyps = List.Tot.Base.rev #(varname * pattern) problem.mp_hyps; mp_goal = problem.mp_goal } in debug ("Got matching problem: " ^ (string_of_matching_problem mp)); mp, continuation /// Continuations /// ------------- /// /// Parsing an abspat yields a matching problem and a continuation of type /// ``abspat_continuation``, which is essentially just a list of binders and a /// term (the body of the abstraction pattern). (** Get the (quoted) type expected by a specific kind of abspat binder. **) let arg_type_of_binder_kind binder_kind : Tac term = match binder_kind with | ABKVar typ -> typ | ABKHyp -> `binder | ABKGoal -> `unit (** Retrieve the function used to locate a value for a given abspat binder. **) let locate_fn_of_binder_kind binder_kind = match binder_kind with | ABKVar _ -> `ms_locate_var | ABKHyp -> `ms_locate_hyp | ABKGoal -> `ms_locate_unit (** Construct a term fetching the value of an abspat argument from a quoted matching solution ``solution_term``. **) let abspat_arg_of_abspat_argspec solution_term (argspec: abspat_argspec) : Tac term = let loc_fn = locate_fn_of_binder_kind argspec.asa_kind in let name_tm = pack (Tv_Const (C_String (unseal argspec.asa_name.ppname))) in let locate_args = [(arg_type_of_binder_kind argspec.asa_kind, Q_Explicit); (solution_term, Q_Explicit); (name_tm, Q_Explicit)] in mk_app loc_fn locate_args (** Specialize a continuation of type ``abspat_continuation``. This constructs a fully applied version of `continuation`, but it requires a quoted solution to be passed in. **) let rec hoist_and_apply (head:term) (arg_terms:list term) (hoisted_args:list argv) : Tac term = match arg_terms with | [] -> mk_app head (List.rev hoisted_args) | arg_term::rest -> let n = List.Tot.length hoisted_args in //let bv = fresh_bv_named ("x" ^ (string_of_int n)) in let nb : binder = { ppname = seal ("x" ^ string_of_int n); sort = pack Tv_Unknown; uniq = fresh (); qual = Q_Explicit; attrs = [] ; } in pack (Tv_Let false [] nb arg_term (hoist_and_apply head rest ((pack (Tv_Var (binder_to_namedv nb)), Q_Explicit)::hoisted_args))) let specialize_abspat_continuation' (continuation: abspat_continuation) (solution_term:term) : Tac term = let mk_arg_term argspec = abspat_arg_of_abspat_argspec solution_term argspec in let argspecs, body = continuation in hoist_and_apply body (map mk_arg_term argspecs) [] (** Specialize a continuation of type ``abspat_continuation``. This yields a quoted function taking a matching solution and running its body with appropriate bindings. **) let specialize_abspat_continuation (continuation: abspat_continuation) : Tac term = let solution_binder = fresh_binder (`matching_solution) in let solution_term = pack (Tv_Var (binder_to_namedv solution_binder)) in let applied = specialize_abspat_continuation' continuation solution_term in let thunked = pack (Tv_Abs solution_binder applied) in debug ("Specialized into " ^ (term_to_string thunked)); let normalized = beta_reduce thunked in debug ("… which reduces to " ^ (term_to_string normalized)); thunked (** Interpret a continuation of type ``abspat_continuation``. This yields a function taking a matching solution and running the body of the continuation with appropriate bindings. **) let interp_abspat_continuation (a:Type0) (continuation: abspat_continuation) : Tac (matching_solution -> Tac a) = let applied = specialize_abspat_continuation continuation in unquote #(matching_solution -> Tac a) applied /// Putting it all together /// ======================= /// /// We now have all we need to use pattern-matching, short of a few convenience functions: (** Construct a matching problem from an abspat. **) let interp_abspat #a (abspat: a) : Tac (matching_problem * abspat_continuation) = matching_problem_of_abs (quote abspat) (** Construct an solve a matching problem. This higher-order function isn't very usable on its own — it's mostly a convenience function to avoid duplicating the problem-parsing code. **) let match_abspat #b #a (abspat: a) (k: abspat_continuation -> Tac (matching_solution -> Tac b)) : Tac b = let goal = cur_goal () in let hypotheses = vars_of_env (cur_env ()) in let problem, continuation = interp_abspat abspat in solve_mp problem hypotheses goal (k continuation) (** Inspect the matching problem produced by parsing an abspat. **) let inspect_abspat_problem #a (abspat: a) : Tac matching_problem = fst (interp_abspat #a abspat) (** Inspect the matching solution produced by parsing and solving an abspat. **) let inspect_abspat_solution #a (abspat: a) : Tac matching_solution = match_abspat abspat (fun _ -> (fun solution -> solution <: Tac _) <: Tac _)

x: a -> FStar.Tactics.Effect.Tac (_: b -> FStar.Tactics.Effect.Tac (a * b))

FStar.Tactics.Effect.Tac

let tpair #a #b (x: a) : Tac (b -> Tac (a * b)) =

fun (y: b) -> (x, y)

Pulse.Checker.IntroPure.fst

Pulse.Checker.IntroPure.check_prop

val check_prop (g: env) (p: term) : T.Tac (p: term & tot_typing g p tm_prop)

val check_prop (g: env) (p: term) : T.Tac (p: term & tot_typing g p tm_prop)

let check_prop (g:env) (p:term) : T.Tac (p:term & tot_typing g p tm_prop) = let p0 = p in let (| p, p_typing |) = Pulse.Checker.Pure.check_vprop g (tm_pure p) in match p.t with | Tm_Pure pp -> let prop_typing = Pulse.Typing.Metatheory.pure_typing_inversion #_ #pp p_typing in (| pp, prop_typing |) | _ -> fail g None (Printf.sprintf "Impossible: check_intro_pure: checking a pure vprop %s returned a non-pure vprop %s,\ please file a bug-report" (P.term_to_string (tm_pure p0)) (P.term_to_string p))

(* 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.IntroPure open Pulse.Syntax open Pulse.Typing open Pulse.Checker.Base open Pulse.Checker.Prover module T = FStar.Tactics.V2 module P = Pulse.Syntax.Printer

g: Pulse.Typing.Env.env -> p: Pulse.Syntax.Base.term -> FStar.Tactics.Effect.Tac (Prims.dtuple2 Pulse.Syntax.Base.term (fun p -> Pulse.Typing.tot_typing g p Pulse.Typing.tm_prop))

FStar.Tactics.Effect.Tac

let check_prop (g: env) (p: term) : T.Tac (p: term & tot_typing g p tm_prop) =

let p0 = p in let (| p , p_typing |) = Pulse.Checker.Pure.check_vprop g (tm_pure p) in match p.t with | Tm_Pure pp -> let prop_typing = Pulse.Typing.Metatheory.pure_typing_inversion #_ #pp p_typing in (| pp, prop_typing |) | _ -> fail g None (Printf.sprintf "Impossible: check_intro_pure: checking a pure vprop %s returned a non-pure vprop %s,please file a bug-report" (P.term_to_string (tm_pure p0)) (P.term_to_string p))

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.interp_abspat

val interp_abspat (#a: _) (abspat: a) : Tac (matching_problem * abspat_continuation)

val interp_abspat (#a: _) (abspat: a) : Tac (matching_problem * abspat_continuation)

let interp_abspat #a (abspat: a) : Tac (matching_problem * abspat_continuation) = matching_problem_of_abs (quote abspat)

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp" let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)" /// The exception monad /// ------------------- noeq type match_res a = | Success of a | Failure of match_exception let return #a (x: a) : match_res a = Success x let (let?) (#a #b: Type) (f: match_res a) (g: a -> Tac (match_res b)) : Tac (match_res b) = match f with | Success aa -> g aa | Failure ex -> Failure ex let raise #a (ex: match_exception) : match_res a = Failure ex /// Liftings /// -------- /// /// There's a natural lifting from the exception monad into the tactic effect: let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern interpretation /// ====================== /// /// This section implement pattern-matching. This is strictly a one term, one /// pattern implementation — handling cases in which mutliple hypotheses match /// the same pattern is done later. type bindings = list (varname * term) let string_of_bindings (bindings: bindings) = String.concat "\n" (map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm)) bindings) (** Match a pattern against a term. `cur_bindings` is a list of bindings collected while matching previous parts of the pattern. Returns a result in the exception monad. **) let rec interp_pattern_aux (pat: pattern) (cur_bindings: bindings) (tm:term) : Tac (match_res bindings) = let interp_var (v: varname) cur_bindings tm = match List.Tot.Base.assoc v cur_bindings with | Some tm' -> if term_eq tm tm' then return cur_bindings else raise (NonLinearMismatch (v, tm, tm')) | None -> return ((v, tm) :: cur_bindings) in let interp_qn (qn: qn) cur_bindings tm = match inspect tm with | Tv_UInst fv _ | Tv_FVar fv -> if fv_to_string fv = qn then return cur_bindings else raise (NameMismatch (qn, (fv_to_string fv))) | _ -> raise (SimpleMismatch (pat, tm)) in let interp_type cur_bindings tm = match inspect tm with | Tv_Type _ -> return cur_bindings | _ -> raise (SimpleMismatch (pat, tm)) in let interp_app (p_hd p_arg: (p:pattern{p << pat})) cur_bindings tm = match inspect tm with | Tv_App hd (arg, _) -> let? with_hd = interp_pattern_aux p_hd cur_bindings hd in let? with_arg = interp_pattern_aux p_arg with_hd arg in return with_arg | _ -> raise (SimpleMismatch (pat, tm)) in match pat with | PVar var -> interp_var var cur_bindings tm | PQn qn -> interp_qn qn cur_bindings tm | PType -> interp_type cur_bindings tm | PApp p_hd p_arg -> interp_app p_hd p_arg cur_bindings tm (** Match a pattern `pat` against a term. Returns a result in the exception monad. **) let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) = fun (tm: term) -> let? rev_bindings = interp_pattern_aux pat [] tm in return (List.Tot.Base.rev rev_bindings) (** Match a term `tm` against a pattern `pat`. Raises an exception if the match fails. This is mostly useful for debugging: use ``mgw`` to capture matches. **) let match_term pat (tm : term) : Tac bindings = match interp_pattern pat (norm_term [] tm) with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern-matching problems /// ========================= /// /// Generalizing past single-term single-pattern problems, we obtain the /// following notions of pattern-matching problems and solutions: let debug msg : Tac unit = () // print msg /// Definitions /// ----------- let absvar = binding type hypothesis = binding /// A matching problem is composed of holes (``mp_vars``), hypothesis patterns /// (``mp_hyps``), and a goal pattern (``mp_goal``). noeq type matching_problem = { mp_vars: list varname; mp_hyps: list (varname * pattern); mp_goal: option pattern } let string_of_matching_problem mp = let vars = String.concat ", " mp.mp_vars in let hyps = String.concat "\n " (List.Tot.Base.map (fun (nm, pat) -> nm ^ ": " ^ (string_of_pattern pat)) mp.mp_hyps) in let goal = match mp.mp_goal with | None -> "_" | Some pat -> string_of_pattern pat in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ "\n" ^ " goal: " ^ goal ^ " }" /// A solution is composed of terms captured to mach the holes, and binders /// captured to match hypothesis patterns. noeq type matching_solution = { ms_vars: list (varname * term); ms_hyps: list (varname * hypothesis) } let string_of_matching_solution ms = let vars = String.concat "\n " (map (fun (varname, tm) -> varname ^ ": " ^ (term_to_string tm)) ms.ms_vars) in let hyps = String.concat "\n " (map (fun (nm, binding) -> nm ^ ": " ^ (binding_to_string binding)) ms.ms_hyps) in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ " }" (** Find a varname in an association list; fail if it can't be found. **) let assoc_varname_fail (#b: Type) (key: varname) (ls: list (varname * b)) : Tac b = match List.Tot.Base.assoc key ls with | None -> fail ("Not found: " ^ key) | Some x -> x let ms_locate_hyp (a: Type) (solution: matching_solution) (name: varname) : Tac hypothesis = assoc_varname_fail name solution.ms_hyps let ms_locate_var (a: Type) (solution: matching_solution) (name: varname) : Tac a = unquote #a (assoc_varname_fail name solution.ms_vars) let ms_locate_unit (a: Type) _solution _binder_name : Tac unit = () /// Resolution /// ---------- /// /// Solving a matching problem is a two-steps process: find an initial /// assignment for holes based on the goal pattern, then find a set of /// hypotheses matching hypothesis patterns. /// /// Note that the implementation takes a continuation of type /// ``matching_solution -> Tac a``. This continuation is needed because we want /// users to be able to provide extra criteria on matching solutions (most /// commonly, this criterion is that a particular tactic should run /// successfuly). /// /// This makes it easy to implement a simple for of search through the context, /// where one can find a hypothesis matching a particular predicate by /// constructing a trivial matching problem and passing the predicate as the /// continuation. (** Scan ``hypotheses`` for a match for ``pat`` that lets ``body`` succeed. ``name`` is used to refer to the hypothesis matched in the final solution. ``part_sol`` includes bindings gathered while matching previous solutions. **) let rec solve_mp_for_single_hyp #a (name: varname) (pat: pattern) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (part_sol: matching_solution) : Tac a = match hypotheses with | [] -> fail #a "No matching hypothesis" | h :: hs -> or_else // Must be in ``Tac`` here to run `body` (fun () -> match interp_pattern_aux pat part_sol.ms_vars (type_of_binding h) with | Failure ex -> fail ("Failed to match hyp: " ^ (string_of_match_exception ex)) | Success bindings -> let ms_hyps = (name, h) :: part_sol.ms_hyps in body ({ part_sol with ms_vars = bindings; ms_hyps = ms_hyps })) (fun () -> solve_mp_for_single_hyp name pat hs body part_sol) (** Scan ``hypotheses`` for matches for ``mp_hyps`` that lets ``body`` succeed. **) let rec solve_mp_for_hyps #a (mp_hyps: list (varname * pattern)) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (partial_solution: matching_solution) : Tac a = match mp_hyps with | [] -> body partial_solution | (name, pat) :: pats -> solve_mp_for_single_hyp name pat hypotheses (solve_mp_for_hyps pats hypotheses body) partial_solution (** Solve a matching problem. The solution returned is constructed to ensure that the continuation ``body`` succeeds: this implements the usual backtracking-match semantics. **) let solve_mp #a (problem: matching_problem) (hypotheses: list hypothesis) (goal: term) (body: matching_solution -> Tac a) : Tac a = let goal_ps = match problem.mp_goal with | None -> { ms_vars = []; ms_hyps = [] } | Some pat -> match interp_pattern pat goal with | Failure ex -> fail ("Failed to match goal: " ^ (string_of_match_exception ex)) | Success bindings -> { ms_vars = bindings; ms_hyps = [] } in solve_mp_for_hyps #a problem.mp_hyps hypotheses body goal_ps /// A DSL for pattern-matching /// ========================== /// /// Using pattern-matching problems as defined above is relatively cumbersome, /// so we now introduce a lightweight notation, in two steps: pattern notations, /// and matching-problem notations. /// /// Pattern notations /// ----------------- /// /// The first part of our pattern-matching syntax is pattern notations: we /// provide a reflective function which constructs a pattern from a term: /// variables are holes, free variables are constants, and applications are /// application patterns. (* FIXME: MOVE *) let name_of_namedv (x:namedv) : Tac string = unseal (inspect_namedv x).ppname (** Compile a term `tm` into a pattern. **) let rec pattern_of_term_ex tm : Tac (match_res pattern) = match inspect tm with | Tv_Var bv -> return (PVar (name_of_namedv bv)) | Tv_FVar fv | Tv_UInst fv _ -> let qn = fv_to_string fv in return (PQn qn) | Tv_Type _ -> return PType | Tv_App f (x, _) -> let? fpat = pattern_of_term_ex f in let? xpat = pattern_of_term_ex x in return (PApp fpat xpat) | _ -> raise (UnsupportedTermInPattern tm) (** β-reduce a term `tm`. This is useful to remove needles function applications introduced by F*, like ``(fun a b c -> a) 1 2 3``. **) let beta_reduce (tm: term) : Tac term = norm_term [] tm (** Compile a term `tm` into a pattern. **) let pattern_of_term tm : Tac pattern = match pattern_of_term_ex tm with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Problem notations /// ----------------- /// /// We then introduce a DSL for matching problems, best explained on the /// following example:: /// /// (fun (a b c: ①) (h1 h2 h3: hyp ②) (g: pm_goal ③) → ④) /// /// This notation is intended to express a pattern-matching problems with three /// holes ``a``, ``b``, and ``c`` of type ①, matching hypotheses ``h1``, ``h2``, /// and ``h3`` against pattern ② and the goal against the pattern ③. The body /// of the notation (④) is then run with appropriate terms bound to ``a``, /// ``b``, and ``c``, appropriate binders bound to ``h1``, ``h2``, and ``h3``, /// and ``()`` bound to ``g``. /// /// We call these patterns ``abspat``s (abstraction patterns), and we provide /// facilities to parse them into matching problems, and to run their bodies /// against a particular matching solution. // We used to annotate variables with an explicit 'var' marker, but then that // var annotation leaked into the types of other hypotheses due to type // inference, requiring non-trivial normalization. // let var (a: Type) = a let hyp (a: Type) = binding let pm_goal (a: Type) = unit let hyp_qn = `%hyp let goal_qn = `%pm_goal noeq type abspat_binder_kind = | ABKVar of typ | ABKHyp | ABKGoal let string_of_abspat_binder_kind = function | ABKVar _ -> "varname" | ABKHyp -> "hyp" | ABKGoal -> "goal" noeq type abspat_argspec = { asa_name: absvar; asa_kind: abspat_binder_kind } // We must store this continuation, because recomputing it yields different // names when the binders are re-opened. type abspat_continuation = list abspat_argspec * term let type_of_named_binder (nb : binder) : term = nb.sort let classify_abspat_binder (b : binder): Tac (abspat_binder_kind * term) = let varname = "v" in let hyp_pat = PApp (PQn hyp_qn) (PVar varname) in let goal_pat = PApp (PQn goal_qn) (PVar varname) in let typ = type_of_named_binder b in match interp_pattern hyp_pat typ with | Success [(_, hyp_typ)] -> ABKHyp, hyp_typ | Success _ -> fail "classifiy_abspat_binder: impossible (1)" | Failure _ -> match interp_pattern goal_pat typ with | Success [(_, goal_typ)] -> ABKGoal, goal_typ | Success _ -> fail "classifiy_abspat_binder: impossible (2)" | Failure _ -> ABKVar typ, typ (** Split an abstraction `tm` into a list of binders and a body. **) let rec binders_and_body_of_abs tm : Tac (list binder * term) = match inspect tm with | Tv_Abs binder tm -> let binders, body = binders_and_body_of_abs tm in binder :: binders, body | _ -> [], tm let cleanup_abspat (t: term) : Tac term = norm_term [] t let name_of_named_binder (nb : binder) : Tac string = unseal nb.ppname (** Parse a notation into a matching problem and a continuation. Pattern-matching notations are of the form ``(fun binders… -> continuation)``, where ``binders`` are of one of the forms ``var …``, ``hyp …``, or ``goal …``. ``var`` binders are typed holes to be used in other binders; ``hyp`` binders indicate a pattern to be matched against hypotheses; and ``goal`` binders match the goal. A reduction phase is run to ensure that the pattern looks reasonable; it is needed because F* tends to infer arguments in β-expanded form. The continuation returned can't directly be applied to a pattern-matching solution; see ``interp_abspat_continuation`` below for that. **) let matching_problem_of_abs (tm: term) : Tac (matching_problem * abspat_continuation) = let binders, body = binders_and_body_of_abs (cleanup_abspat tm) in debug ("Got binders: " ^ (String.concat ", " (map (fun b -> name_of_named_binder b <: Tac string) binders))); let classified_binders : list (binder & string & abspat_binder_kind & typ) = map (fun binder -> let bv_name = name_of_named_binder binder in debug ("Got binder: " ^ bv_name ^ "; type is " ^ term_to_string (type_of_named_binder binder)); let binder_kind, typ = classify_abspat_binder binder in (binder, bv_name, binder_kind, typ)) binders in let problem = fold_left (fun problem (binder, bv_name, binder_kind, typ) -> debug ("Compiling binder " ^ name_of_named_binder binder ^ ", classified as " ^ string_of_abspat_binder_kind binder_kind ^ ", with type " ^ term_to_string typ); match binder_kind with | ABKVar _ -> { problem with mp_vars = bv_name :: problem.mp_vars } | ABKHyp -> { problem with mp_hyps = (bv_name, (pattern_of_term typ)) :: problem.mp_hyps } | ABKGoal -> { problem with mp_goal = Some (pattern_of_term typ) }) ({ mp_vars = []; mp_hyps = []; mp_goal = None }) classified_binders in let continuation = let abspat_argspec_of_binder xx : Tac abspat_argspec = match xx with | (binder, xx, binder_kind, yy) -> { asa_name = binder_to_binding binder; asa_kind = binder_kind } in (map abspat_argspec_of_binder classified_binders, tm) in let mp = { mp_vars = List.Tot.Base.rev #varname problem.mp_vars; mp_hyps = List.Tot.Base.rev #(varname * pattern) problem.mp_hyps; mp_goal = problem.mp_goal } in debug ("Got matching problem: " ^ (string_of_matching_problem mp)); mp, continuation /// Continuations /// ------------- /// /// Parsing an abspat yields a matching problem and a continuation of type /// ``abspat_continuation``, which is essentially just a list of binders and a /// term (the body of the abstraction pattern). (** Get the (quoted) type expected by a specific kind of abspat binder. **) let arg_type_of_binder_kind binder_kind : Tac term = match binder_kind with | ABKVar typ -> typ | ABKHyp -> `binder | ABKGoal -> `unit (** Retrieve the function used to locate a value for a given abspat binder. **) let locate_fn_of_binder_kind binder_kind = match binder_kind with | ABKVar _ -> `ms_locate_var | ABKHyp -> `ms_locate_hyp | ABKGoal -> `ms_locate_unit (** Construct a term fetching the value of an abspat argument from a quoted matching solution ``solution_term``. **) let abspat_arg_of_abspat_argspec solution_term (argspec: abspat_argspec) : Tac term = let loc_fn = locate_fn_of_binder_kind argspec.asa_kind in let name_tm = pack (Tv_Const (C_String (unseal argspec.asa_name.ppname))) in let locate_args = [(arg_type_of_binder_kind argspec.asa_kind, Q_Explicit); (solution_term, Q_Explicit); (name_tm, Q_Explicit)] in mk_app loc_fn locate_args (** Specialize a continuation of type ``abspat_continuation``. This constructs a fully applied version of `continuation`, but it requires a quoted solution to be passed in. **) let rec hoist_and_apply (head:term) (arg_terms:list term) (hoisted_args:list argv) : Tac term = match arg_terms with | [] -> mk_app head (List.rev hoisted_args) | arg_term::rest -> let n = List.Tot.length hoisted_args in //let bv = fresh_bv_named ("x" ^ (string_of_int n)) in let nb : binder = { ppname = seal ("x" ^ string_of_int n); sort = pack Tv_Unknown; uniq = fresh (); qual = Q_Explicit; attrs = [] ; } in pack (Tv_Let false [] nb arg_term (hoist_and_apply head rest ((pack (Tv_Var (binder_to_namedv nb)), Q_Explicit)::hoisted_args))) let specialize_abspat_continuation' (continuation: abspat_continuation) (solution_term:term) : Tac term = let mk_arg_term argspec = abspat_arg_of_abspat_argspec solution_term argspec in let argspecs, body = continuation in hoist_and_apply body (map mk_arg_term argspecs) [] (** Specialize a continuation of type ``abspat_continuation``. This yields a quoted function taking a matching solution and running its body with appropriate bindings. **) let specialize_abspat_continuation (continuation: abspat_continuation) : Tac term = let solution_binder = fresh_binder (`matching_solution) in let solution_term = pack (Tv_Var (binder_to_namedv solution_binder)) in let applied = specialize_abspat_continuation' continuation solution_term in let thunked = pack (Tv_Abs solution_binder applied) in debug ("Specialized into " ^ (term_to_string thunked)); let normalized = beta_reduce thunked in debug ("… which reduces to " ^ (term_to_string normalized)); thunked (** Interpret a continuation of type ``abspat_continuation``. This yields a function taking a matching solution and running the body of the continuation with appropriate bindings. **) let interp_abspat_continuation (a:Type0) (continuation: abspat_continuation) : Tac (matching_solution -> Tac a) = let applied = specialize_abspat_continuation continuation in unquote #(matching_solution -> Tac a) applied /// Putting it all together /// ======================= /// /// We now have all we need to use pattern-matching, short of a few convenience functions:

abspat: a -> FStar.Tactics.Effect.Tac (FStar.Tactics.PatternMatching.matching_problem * FStar.Tactics.PatternMatching.abspat_continuation)

FStar.Tactics.Effect.Tac

let interp_abspat #a (abspat: a) : Tac (matching_problem * abspat_continuation) =

matching_problem_of_abs (quote abspat)

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.string_of_pattern

val string_of_pattern : _: FStar.Tactics.PatternMatching.pattern -> Prims.string

let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")"

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application"

_: FStar.Tactics.PatternMatching.pattern -> Prims.string

Prims.Tot

let rec string_of_pattern =

function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")"

Pulse.Elaborate.Core.fst

Pulse.Elaborate.Core.elab_br

val elab_br (#g: env) (#c: comp_st) (#sc_u: universe) (#sc_ty: typ) (#sc: term) (#p: pattern) (#e: st_term) (d: br_typing g sc_u sc_ty sc p e c) : Tot R.branch (decreases d)

val elab_br (#g: env) (#c: comp_st) (#sc_u: universe) (#sc_ty: typ) (#sc: term) (#p: pattern) (#e: st_term) (d: br_typing g sc_u sc_ty sc p e c) : Tot R.branch (decreases d)

let rec elab_st_typing (#g:env) (#t:st_term) (#c:comp) (d:st_typing g t c) : Tot R.term (decreases d) = match d with // | T_Tot _ t _ _ -> elab_term t | T_Abs _ x qual b _u body _c ty_typing body_typing -> let ty = elab_term b.binder_ty in let ppname = b.binder_ppname.name in let body = elab_st_typing body_typing in mk_abs_with_name ppname ty (elab_qual qual) (RT.close_term body x) //this closure should be provably redundant by strengthening the conditions on x | T_STApp _ head _ qual _ arg _ _ | T_STGhostApp _ head _ qual _ arg _ _ _ _ -> let head = elab_term head in let arg = elab_term arg in R.mk_app head [(arg, elab_qual qual)] | T_Return _ c use_eq u ty t post _ _ _ _ -> let ru = u in let rty = elab_term ty in let rt = elab_term t in let rp = elab_term post in let rp = mk_abs rty R.Q_Explicit rp in (match c, use_eq with | STT, true -> mk_stt_return ru rty rt rp | STT, false -> mk_stt_return_noeq ru rty rt rp | STT_Atomic, true -> mk_stt_atomic_return ru rty rt rp | STT_Atomic, false -> mk_stt_atomic_return_noeq ru rty rt rp | STT_Ghost, true -> mk_stt_ghost_return ru rty rt rp | STT_Ghost, false -> mk_stt_ghost_return_noeq ru rty rt rp) | T_Bind _ e1 e2 c1 c2 b x c e1_typing t_typing e2_typing bc -> let e1 = elab_st_typing e1_typing in let e2 = elab_st_typing e2_typing in let ty1 = elab_term (comp_res c1) in elab_bind bc e1 (mk_abs_with_name b.binder_ppname.name ty1 R.Q_Explicit (RT.close_term e2 x)) | T_BindFn _ _ _ c1 c2 b x e1_typing _u t_typing e2_typing c2_typing -> let e1 = elab_st_typing e1_typing in let e2 = elab_st_typing e2_typing in let ty1 = elab_term (comp_res c1) in RT.mk_let RT.pp_name_default e1 ty1 (RT.close_term e2 x) | T_Frame _ _ c frame _frame_typing e_typing -> let e = elab_st_typing e_typing in elab_frame c frame e | T_Equiv _ _ c1 c2 e_typing (ST_TotEquiv _ _ _ _ _ _) -> let e = elab_st_typing e_typing in e | T_Equiv _ _ c1 c2 e_typing _ -> let e = elab_st_typing e_typing in elab_sub c1 c2 e | T_Sub _ _ c1 c2 e_typing d_sub -> let e = elab_st_typing e_typing in let (| coercion, _ |) = elab_st_sub d_sub in R.mk_e_app coercion [e] | T_Lift _ _ c1 c2 e_typing lc -> let e = elab_st_typing e_typing in elab_lift lc e | T_If _ b _ _ _ _ _ e1_typing e2_typing _c_typing -> let rb = elab_term b in let re1 = elab_st_typing e1_typing in let re2 = elab_st_typing e2_typing in RT.mk_if rb re1 re2 | T_Match _ _ _ sc _ _ _ _ _ brty _ -> let sc = elab_term sc in let brs = elab_branches brty in R.pack_ln (R.Tv_Match sc None brs) | T_IntroPure _ p _ _ -> let head = tm_pureapp (tm_fvar (as_fv (mk_pulse_lib_core_lid "intro_pure"))) None p in let arg = (`()) in R.mk_app (elab_term head) [(arg, elab_qual None)] | T_ElimExists _ u t p _ d_t d_exists -> let ru = u in let rt = elab_term t in let rp = elab_term p in mk_elim_exists ru rt (mk_abs rt R.Q_Explicit rp) | T_IntroExists _ u b p e _ _ _ -> let ru = u in let rt = elab_term b.binder_ty in let rp = elab_term p in let re = elab_term e in mk_intro_exists ru rt (mk_abs rt R.Q_Explicit rp) re | T_While _ inv _ _ _ cond_typing body_typing -> let inv = elab_term inv in let cond = elab_st_typing cond_typing in let body = elab_st_typing body_typing in mk_while (mk_abs bool_tm R.Q_Explicit inv) cond body | T_Par _ eL cL eR cR _ _ _ eL_typing eR_typing -> let ru = comp_u cL in let raL = elab_term (comp_res cL) in let raR = elab_term (comp_res cR) in let rpreL = elab_term (comp_pre cL) in let rpostL = elab_term (comp_post cL) in let rpreR = elab_term (comp_pre cR) in let rpostR = elab_term (comp_post cR) in let reL = elab_st_typing eL_typing in let reR = elab_st_typing eR_typing in mk_par ru raL raR rpreL (mk_abs raL R.Q_Explicit rpostL) rpreR (mk_abs raR R.Q_Explicit rpostR) reL reR | T_Rewrite _ p q _ _ -> let rp = elab_term p in let rq = elab_term q in mk_rewrite rp rq | T_WithLocal _ _ init _ init_t c x _ _ _ body_typing -> let rret_u = comp_u c in let ra = elab_term init_t in let rinit = elab_term init in let rret_t = elab_term (comp_res c) in let rpre = elab_term (comp_pre c) in let rpost = mk_abs rret_t R.Q_Explicit (elab_term (comp_post c)) in let rbody = elab_st_typing body_typing in let rbody = RT.close_term rbody x in let rbody = mk_abs (mk_ref ra) R.Q_Explicit rbody in mk_withlocal rret_u ra rinit rpre rret_t rpost rbody | T_WithLocalArray _ _ init len _ init_t c x _ _ _ _ body_typing -> let rret_u = comp_u c in let ra = elab_term init_t in let rinit = elab_term init in let rlen = elab_term len in let rret_t = elab_term (comp_res c) in let rpre = elab_term (comp_pre c) in let rpost = mk_abs rret_t R.Q_Explicit (elab_term (comp_post c)) in let rbody = elab_st_typing body_typing in let rbody = RT.close_term rbody x in let rbody = mk_abs (mk_array ra) R.Q_Explicit rbody in mk_withlocalarray rret_u ra rinit rlen rpre rret_t rpost rbody | T_Admit _ {u;res;pre;post} c _ -> let ru = u in let rres = elab_term res in let rpre = elab_term pre in let rpost = elab_term post in let rpost = mk_abs rres R.Q_Explicit rpost in (match c with | STT -> mk_stt_admit ru rres rpre rpost | STT_Atomic -> mk_stt_atomic_admit ru rres rpre rpost | STT_Ghost -> mk_stt_ghost_admit ru rres rpre rpost) | T_Unreachable _ _ _ _ _ -> `("IOU: elab_st_typing of T_Unreachable") | T_WithInv _ _ _ _ _ _ _ _ _ -> `("IOU: elab_st_typing of T_WithInv") and elab_br (#g:env) (#c:comp_st) (#sc_u:universe) (#sc_ty:typ) (#sc:term) (#p:pattern) (#e:st_term) (d : br_typing g sc_u sc_ty sc p e c) : Tot R.branch (decreases d) = let TBR _ _ _ _ _ _ _ _ bs _ _ _ ed = d in let e = elab_st_typing ed in (elab_pat p, e) and elab_branches (#g:env) (#c:comp_st) (#sc_u:universe) (#sc_ty:typ) (#sc:term) (#brs:list branch) (d : brs_typing g sc_u sc_ty sc brs c) : Tot (list R.branch) (decreases d) = match d with | TBRS_0 _ -> [] | TBRS_1 _ p e bd _ d' -> elab_br bd :: elab_branches d'

(* 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.Elaborate.Core module RT = FStar.Reflection.Typing module R = FStar.Reflection.V2 module L = FStar.List.Tot module T = FStar.Tactics.V2 open FStar.List.Tot open Pulse.Syntax open Pulse.Elaborate.Pure open Pulse.Typing module RU = Pulse.RuntimeUtils open Pulse.Reflection.Util let elab_frame (c:comp_st) (frame:term) (e:R.term) = let u = comp_u c in let ty = elab_term (comp_res c) in let pre = elab_term (comp_pre c) in let post = elab_term (comp_post c) in if C_ST? c then mk_frame_stt u ty pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e else if C_STAtomic? c then let opened = elab_term (comp_inames c) in mk_frame_stt_atomic u ty opened pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e else mk_frame_stt_ghost u ty pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e let elab_sub (c1 c2:comp_st) (e:R.term) = let ty = elab_term (comp_res c1) in let u = comp_u c1 in let pre1 = elab_term (comp_pre c1) in let pre2 = elab_term (comp_pre c2) in let post1 = mk_abs ty R.Q_Explicit (elab_term (comp_post c1)) in let post2 = mk_abs ty R.Q_Explicit (elab_term (comp_post c2)) in if C_ST? c1 then mk_sub_stt u ty pre1 pre2 post1 post2 e else if C_STAtomic? c1 then let opened = elab_term (comp_inames c1) in mk_sub_stt_atomic u ty opened pre1 pre2 post1 post2 e else mk_sub_stt_ghost u ty pre1 pre2 post1 post2 e let elab_bind #g #x #c1 #c2 #c (bc:bind_comp g x c1 c2 c) (e1 e2:R.term) : R.term = let t1 = elab_term (comp_res c1) in let t2 = elab_term (comp_res c2) in match c1 with | C_ST _ -> mk_bind_stt (comp_u c1) (comp_u c2) t1 t2 (elab_term (comp_pre c1)) (mk_abs t1 R.Q_Explicit (elab_term (comp_post c1))) (mk_abs t2 R.Q_Explicit (elab_term (comp_post c2))) e1 e2 | C_STGhost _ -> mk_bind_ghost (comp_u c1) (comp_u c2) t1 t2 (elab_term (comp_pre c1)) (mk_abs t1 R.Q_Explicit (elab_term (comp_post c1))) (mk_abs t2 R.Q_Explicit (elab_term (comp_post c2))) e1 e2 | C_STAtomic inames obs1 _ -> let C_STAtomic _ obs2 _ = c2 in mk_bind_atomic (comp_u c1) (comp_u c2) (elab_observability obs1) (elab_observability obs2) (elab_term (comp_inames c1)) t1 t2 (elab_term (comp_pre c1)) (mk_abs t1 R.Q_Explicit (elab_term (comp_post c1))) (mk_abs t2 R.Q_Explicit (elab_term (comp_post c2))) e1 e2 let elab_lift #g #c1 #c2 (d:lift_comp g c1 c2) (e:R.term) : Tot R.term = match d with | Lift_STAtomic_ST _ _ -> let t = elab_term (comp_res c1) in mk_lift_atomic_stt (comp_u c1) (elab_term (comp_res c1)) t (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e | Lift_Observability _ c o2 -> let t = elab_term (comp_res c1) in mk_lift_observability (comp_u c1) (elab_observability (C_STAtomic?.obs c)) (elab_observability o2) (elab_term (comp_inames c1)) t (elab_term (comp_pre c1)) (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e | Lift_Ghost_Neutral _ _ (| reveal_a, reveal_a_typing |) -> let t = elab_term (comp_res c1) in mk_lift_ghost_neutral (comp_u c1) t (elab_term (comp_pre c1)) (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e (elab_term reveal_a) | Lift_Neutral_Ghost _ c -> let t = elab_term (comp_res c1) in mk_lift_neutral_ghost (comp_u c1) t (elab_term (comp_pre c1)) (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e let intro_pure_tm (p:term) = let open Pulse.Reflection.Util in wtag (Some STT_Ghost) (Tm_STApp { head = tm_pureapp (tm_fvar (as_fv (mk_pulse_lib_core_lid "intro_pure"))) None p; arg_qual = None; arg = tm_fstar (`()) Range.range_0 }) let simple_arr (t1 t2 : R.term) : R.term = let b = R.pack_binder { sort = t1; ppname = Sealed.seal "x"; qual = R.Q_Explicit; attrs = [] } in R.pack_ln (R.Tv_Arrow b (R.pack_comp (R.C_Total t2))) let elab_st_sub (#g:env) (#c1 #c2 : comp) (d_sub : st_sub g c1 c2) : Tot (t:R.term & RT.tot_typing (elab_env g) t (simple_arr (elab_comp c1) (elab_comp c2))) = RU.magic_s "elab_st_sub"

d: Pulse.Typing.br_typing g sc_u sc_ty sc p e c -> Prims.Tot FStar.Stubs.Reflection.V2.Data.branch

Prims.Tot

let rec elab_br (#g: env) (#c: comp_st) (#sc_u: universe) (#sc_ty: typ) (#sc: term) (#p: pattern) (#e: st_term) (d: br_typing g sc_u sc_ty sc p e c) : Tot R.branch (decreases d) =

let TBR _ _ _ _ _ _ _ _ bs _ _ _ ed = d in let e = elab_st_typing ed in (elab_pat p, e)

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.lift_exn_tac

val lift_exn_tac (#a #b: _) (f: (a -> match_res b)) (aa: a) : Tac b

val lift_exn_tac (#a #b: _) (f: (a -> match_res b)) (aa: a) : Tac b

let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex)

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp" let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)" /// The exception monad /// ------------------- noeq type match_res a = | Success of a | Failure of match_exception let return #a (x: a) : match_res a = Success x let (let?) (#a #b: Type) (f: match_res a) (g: a -> Tac (match_res b)) : Tac (match_res b) = match f with | Success aa -> g aa | Failure ex -> Failure ex let raise #a (ex: match_exception) : match_res a = Failure ex /// Liftings /// -------- /// /// There's a natural lifting from the exception monad into the tactic effect:

f: (_: a -> FStar.Tactics.PatternMatching.match_res b) -> aa: a -> FStar.Tactics.Effect.Tac b

FStar.Tactics.Effect.Tac

let lift_exn_tac #a #b (f: (a -> match_res b)) (aa: a) : Tac b =

match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex)

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.match_abspat

val match_abspat (#b #a: _) (abspat: a) (k: (abspat_continuation -> Tac (matching_solution -> Tac b))) : Tac b

val match_abspat (#b #a: _) (abspat: a) (k: (abspat_continuation -> Tac (matching_solution -> Tac b))) : Tac b

let match_abspat #b #a (abspat: a) (k: abspat_continuation -> Tac (matching_solution -> Tac b)) : Tac b = let goal = cur_goal () in let hypotheses = vars_of_env (cur_env ()) in let problem, continuation = interp_abspat abspat in solve_mp problem hypotheses goal (k continuation)

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp" let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)" /// The exception monad /// ------------------- noeq type match_res a = | Success of a | Failure of match_exception let return #a (x: a) : match_res a = Success x let (let?) (#a #b: Type) (f: match_res a) (g: a -> Tac (match_res b)) : Tac (match_res b) = match f with | Success aa -> g aa | Failure ex -> Failure ex let raise #a (ex: match_exception) : match_res a = Failure ex /// Liftings /// -------- /// /// There's a natural lifting from the exception monad into the tactic effect: let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern interpretation /// ====================== /// /// This section implement pattern-matching. This is strictly a one term, one /// pattern implementation — handling cases in which mutliple hypotheses match /// the same pattern is done later. type bindings = list (varname * term) let string_of_bindings (bindings: bindings) = String.concat "\n" (map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm)) bindings) (** Match a pattern against a term. `cur_bindings` is a list of bindings collected while matching previous parts of the pattern. Returns a result in the exception monad. **) let rec interp_pattern_aux (pat: pattern) (cur_bindings: bindings) (tm:term) : Tac (match_res bindings) = let interp_var (v: varname) cur_bindings tm = match List.Tot.Base.assoc v cur_bindings with | Some tm' -> if term_eq tm tm' then return cur_bindings else raise (NonLinearMismatch (v, tm, tm')) | None -> return ((v, tm) :: cur_bindings) in let interp_qn (qn: qn) cur_bindings tm = match inspect tm with | Tv_UInst fv _ | Tv_FVar fv -> if fv_to_string fv = qn then return cur_bindings else raise (NameMismatch (qn, (fv_to_string fv))) | _ -> raise (SimpleMismatch (pat, tm)) in let interp_type cur_bindings tm = match inspect tm with | Tv_Type _ -> return cur_bindings | _ -> raise (SimpleMismatch (pat, tm)) in let interp_app (p_hd p_arg: (p:pattern{p << pat})) cur_bindings tm = match inspect tm with | Tv_App hd (arg, _) -> let? with_hd = interp_pattern_aux p_hd cur_bindings hd in let? with_arg = interp_pattern_aux p_arg with_hd arg in return with_arg | _ -> raise (SimpleMismatch (pat, tm)) in match pat with | PVar var -> interp_var var cur_bindings tm | PQn qn -> interp_qn qn cur_bindings tm | PType -> interp_type cur_bindings tm | PApp p_hd p_arg -> interp_app p_hd p_arg cur_bindings tm (** Match a pattern `pat` against a term. Returns a result in the exception monad. **) let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) = fun (tm: term) -> let? rev_bindings = interp_pattern_aux pat [] tm in return (List.Tot.Base.rev rev_bindings) (** Match a term `tm` against a pattern `pat`. Raises an exception if the match fails. This is mostly useful for debugging: use ``mgw`` to capture matches. **) let match_term pat (tm : term) : Tac bindings = match interp_pattern pat (norm_term [] tm) with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern-matching problems /// ========================= /// /// Generalizing past single-term single-pattern problems, we obtain the /// following notions of pattern-matching problems and solutions: let debug msg : Tac unit = () // print msg /// Definitions /// ----------- let absvar = binding type hypothesis = binding /// A matching problem is composed of holes (``mp_vars``), hypothesis patterns /// (``mp_hyps``), and a goal pattern (``mp_goal``). noeq type matching_problem = { mp_vars: list varname; mp_hyps: list (varname * pattern); mp_goal: option pattern } let string_of_matching_problem mp = let vars = String.concat ", " mp.mp_vars in let hyps = String.concat "\n " (List.Tot.Base.map (fun (nm, pat) -> nm ^ ": " ^ (string_of_pattern pat)) mp.mp_hyps) in let goal = match mp.mp_goal with | None -> "_" | Some pat -> string_of_pattern pat in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ "\n" ^ " goal: " ^ goal ^ " }" /// A solution is composed of terms captured to mach the holes, and binders /// captured to match hypothesis patterns. noeq type matching_solution = { ms_vars: list (varname * term); ms_hyps: list (varname * hypothesis) } let string_of_matching_solution ms = let vars = String.concat "\n " (map (fun (varname, tm) -> varname ^ ": " ^ (term_to_string tm)) ms.ms_vars) in let hyps = String.concat "\n " (map (fun (nm, binding) -> nm ^ ": " ^ (binding_to_string binding)) ms.ms_hyps) in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ " }" (** Find a varname in an association list; fail if it can't be found. **) let assoc_varname_fail (#b: Type) (key: varname) (ls: list (varname * b)) : Tac b = match List.Tot.Base.assoc key ls with | None -> fail ("Not found: " ^ key) | Some x -> x let ms_locate_hyp (a: Type) (solution: matching_solution) (name: varname) : Tac hypothesis = assoc_varname_fail name solution.ms_hyps let ms_locate_var (a: Type) (solution: matching_solution) (name: varname) : Tac a = unquote #a (assoc_varname_fail name solution.ms_vars) let ms_locate_unit (a: Type) _solution _binder_name : Tac unit = () /// Resolution /// ---------- /// /// Solving a matching problem is a two-steps process: find an initial /// assignment for holes based on the goal pattern, then find a set of /// hypotheses matching hypothesis patterns. /// /// Note that the implementation takes a continuation of type /// ``matching_solution -> Tac a``. This continuation is needed because we want /// users to be able to provide extra criteria on matching solutions (most /// commonly, this criterion is that a particular tactic should run /// successfuly). /// /// This makes it easy to implement a simple for of search through the context, /// where one can find a hypothesis matching a particular predicate by /// constructing a trivial matching problem and passing the predicate as the /// continuation. (** Scan ``hypotheses`` for a match for ``pat`` that lets ``body`` succeed. ``name`` is used to refer to the hypothesis matched in the final solution. ``part_sol`` includes bindings gathered while matching previous solutions. **) let rec solve_mp_for_single_hyp #a (name: varname) (pat: pattern) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (part_sol: matching_solution) : Tac a = match hypotheses with | [] -> fail #a "No matching hypothesis" | h :: hs -> or_else // Must be in ``Tac`` here to run `body` (fun () -> match interp_pattern_aux pat part_sol.ms_vars (type_of_binding h) with | Failure ex -> fail ("Failed to match hyp: " ^ (string_of_match_exception ex)) | Success bindings -> let ms_hyps = (name, h) :: part_sol.ms_hyps in body ({ part_sol with ms_vars = bindings; ms_hyps = ms_hyps })) (fun () -> solve_mp_for_single_hyp name pat hs body part_sol) (** Scan ``hypotheses`` for matches for ``mp_hyps`` that lets ``body`` succeed. **) let rec solve_mp_for_hyps #a (mp_hyps: list (varname * pattern)) (hypotheses: list hypothesis) (body: matching_solution -> Tac a) (partial_solution: matching_solution) : Tac a = match mp_hyps with | [] -> body partial_solution | (name, pat) :: pats -> solve_mp_for_single_hyp name pat hypotheses (solve_mp_for_hyps pats hypotheses body) partial_solution (** Solve a matching problem. The solution returned is constructed to ensure that the continuation ``body`` succeeds: this implements the usual backtracking-match semantics. **) let solve_mp #a (problem: matching_problem) (hypotheses: list hypothesis) (goal: term) (body: matching_solution -> Tac a) : Tac a = let goal_ps = match problem.mp_goal with | None -> { ms_vars = []; ms_hyps = [] } | Some pat -> match interp_pattern pat goal with | Failure ex -> fail ("Failed to match goal: " ^ (string_of_match_exception ex)) | Success bindings -> { ms_vars = bindings; ms_hyps = [] } in solve_mp_for_hyps #a problem.mp_hyps hypotheses body goal_ps /// A DSL for pattern-matching /// ========================== /// /// Using pattern-matching problems as defined above is relatively cumbersome, /// so we now introduce a lightweight notation, in two steps: pattern notations, /// and matching-problem notations. /// /// Pattern notations /// ----------------- /// /// The first part of our pattern-matching syntax is pattern notations: we /// provide a reflective function which constructs a pattern from a term: /// variables are holes, free variables are constants, and applications are /// application patterns. (* FIXME: MOVE *) let name_of_namedv (x:namedv) : Tac string = unseal (inspect_namedv x).ppname (** Compile a term `tm` into a pattern. **) let rec pattern_of_term_ex tm : Tac (match_res pattern) = match inspect tm with | Tv_Var bv -> return (PVar (name_of_namedv bv)) | Tv_FVar fv | Tv_UInst fv _ -> let qn = fv_to_string fv in return (PQn qn) | Tv_Type _ -> return PType | Tv_App f (x, _) -> let? fpat = pattern_of_term_ex f in let? xpat = pattern_of_term_ex x in return (PApp fpat xpat) | _ -> raise (UnsupportedTermInPattern tm) (** β-reduce a term `tm`. This is useful to remove needles function applications introduced by F*, like ``(fun a b c -> a) 1 2 3``. **) let beta_reduce (tm: term) : Tac term = norm_term [] tm (** Compile a term `tm` into a pattern. **) let pattern_of_term tm : Tac pattern = match pattern_of_term_ex tm with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Problem notations /// ----------------- /// /// We then introduce a DSL for matching problems, best explained on the /// following example:: /// /// (fun (a b c: ①) (h1 h2 h3: hyp ②) (g: pm_goal ③) → ④) /// /// This notation is intended to express a pattern-matching problems with three /// holes ``a``, ``b``, and ``c`` of type ①, matching hypotheses ``h1``, ``h2``, /// and ``h3`` against pattern ② and the goal against the pattern ③. The body /// of the notation (④) is then run with appropriate terms bound to ``a``, /// ``b``, and ``c``, appropriate binders bound to ``h1``, ``h2``, and ``h3``, /// and ``()`` bound to ``g``. /// /// We call these patterns ``abspat``s (abstraction patterns), and we provide /// facilities to parse them into matching problems, and to run their bodies /// against a particular matching solution. // We used to annotate variables with an explicit 'var' marker, but then that // var annotation leaked into the types of other hypotheses due to type // inference, requiring non-trivial normalization. // let var (a: Type) = a let hyp (a: Type) = binding let pm_goal (a: Type) = unit let hyp_qn = `%hyp let goal_qn = `%pm_goal noeq type abspat_binder_kind = | ABKVar of typ | ABKHyp | ABKGoal let string_of_abspat_binder_kind = function | ABKVar _ -> "varname" | ABKHyp -> "hyp" | ABKGoal -> "goal" noeq type abspat_argspec = { asa_name: absvar; asa_kind: abspat_binder_kind } // We must store this continuation, because recomputing it yields different // names when the binders are re-opened. type abspat_continuation = list abspat_argspec * term let type_of_named_binder (nb : binder) : term = nb.sort let classify_abspat_binder (b : binder): Tac (abspat_binder_kind * term) = let varname = "v" in let hyp_pat = PApp (PQn hyp_qn) (PVar varname) in let goal_pat = PApp (PQn goal_qn) (PVar varname) in let typ = type_of_named_binder b in match interp_pattern hyp_pat typ with | Success [(_, hyp_typ)] -> ABKHyp, hyp_typ | Success _ -> fail "classifiy_abspat_binder: impossible (1)" | Failure _ -> match interp_pattern goal_pat typ with | Success [(_, goal_typ)] -> ABKGoal, goal_typ | Success _ -> fail "classifiy_abspat_binder: impossible (2)" | Failure _ -> ABKVar typ, typ (** Split an abstraction `tm` into a list of binders and a body. **) let rec binders_and_body_of_abs tm : Tac (list binder * term) = match inspect tm with | Tv_Abs binder tm -> let binders, body = binders_and_body_of_abs tm in binder :: binders, body | _ -> [], tm let cleanup_abspat (t: term) : Tac term = norm_term [] t let name_of_named_binder (nb : binder) : Tac string = unseal nb.ppname (** Parse a notation into a matching problem and a continuation. Pattern-matching notations are of the form ``(fun binders… -> continuation)``, where ``binders`` are of one of the forms ``var …``, ``hyp …``, or ``goal …``. ``var`` binders are typed holes to be used in other binders; ``hyp`` binders indicate a pattern to be matched against hypotheses; and ``goal`` binders match the goal. A reduction phase is run to ensure that the pattern looks reasonable; it is needed because F* tends to infer arguments in β-expanded form. The continuation returned can't directly be applied to a pattern-matching solution; see ``interp_abspat_continuation`` below for that. **) let matching_problem_of_abs (tm: term) : Tac (matching_problem * abspat_continuation) = let binders, body = binders_and_body_of_abs (cleanup_abspat tm) in debug ("Got binders: " ^ (String.concat ", " (map (fun b -> name_of_named_binder b <: Tac string) binders))); let classified_binders : list (binder & string & abspat_binder_kind & typ) = map (fun binder -> let bv_name = name_of_named_binder binder in debug ("Got binder: " ^ bv_name ^ "; type is " ^ term_to_string (type_of_named_binder binder)); let binder_kind, typ = classify_abspat_binder binder in (binder, bv_name, binder_kind, typ)) binders in let problem = fold_left (fun problem (binder, bv_name, binder_kind, typ) -> debug ("Compiling binder " ^ name_of_named_binder binder ^ ", classified as " ^ string_of_abspat_binder_kind binder_kind ^ ", with type " ^ term_to_string typ); match binder_kind with | ABKVar _ -> { problem with mp_vars = bv_name :: problem.mp_vars } | ABKHyp -> { problem with mp_hyps = (bv_name, (pattern_of_term typ)) :: problem.mp_hyps } | ABKGoal -> { problem with mp_goal = Some (pattern_of_term typ) }) ({ mp_vars = []; mp_hyps = []; mp_goal = None }) classified_binders in let continuation = let abspat_argspec_of_binder xx : Tac abspat_argspec = match xx with | (binder, xx, binder_kind, yy) -> { asa_name = binder_to_binding binder; asa_kind = binder_kind } in (map abspat_argspec_of_binder classified_binders, tm) in let mp = { mp_vars = List.Tot.Base.rev #varname problem.mp_vars; mp_hyps = List.Tot.Base.rev #(varname * pattern) problem.mp_hyps; mp_goal = problem.mp_goal } in debug ("Got matching problem: " ^ (string_of_matching_problem mp)); mp, continuation /// Continuations /// ------------- /// /// Parsing an abspat yields a matching problem and a continuation of type /// ``abspat_continuation``, which is essentially just a list of binders and a /// term (the body of the abstraction pattern). (** Get the (quoted) type expected by a specific kind of abspat binder. **) let arg_type_of_binder_kind binder_kind : Tac term = match binder_kind with | ABKVar typ -> typ | ABKHyp -> `binder | ABKGoal -> `unit (** Retrieve the function used to locate a value for a given abspat binder. **) let locate_fn_of_binder_kind binder_kind = match binder_kind with | ABKVar _ -> `ms_locate_var | ABKHyp -> `ms_locate_hyp | ABKGoal -> `ms_locate_unit (** Construct a term fetching the value of an abspat argument from a quoted matching solution ``solution_term``. **) let abspat_arg_of_abspat_argspec solution_term (argspec: abspat_argspec) : Tac term = let loc_fn = locate_fn_of_binder_kind argspec.asa_kind in let name_tm = pack (Tv_Const (C_String (unseal argspec.asa_name.ppname))) in let locate_args = [(arg_type_of_binder_kind argspec.asa_kind, Q_Explicit); (solution_term, Q_Explicit); (name_tm, Q_Explicit)] in mk_app loc_fn locate_args (** Specialize a continuation of type ``abspat_continuation``. This constructs a fully applied version of `continuation`, but it requires a quoted solution to be passed in. **) let rec hoist_and_apply (head:term) (arg_terms:list term) (hoisted_args:list argv) : Tac term = match arg_terms with | [] -> mk_app head (List.rev hoisted_args) | arg_term::rest -> let n = List.Tot.length hoisted_args in //let bv = fresh_bv_named ("x" ^ (string_of_int n)) in let nb : binder = { ppname = seal ("x" ^ string_of_int n); sort = pack Tv_Unknown; uniq = fresh (); qual = Q_Explicit; attrs = [] ; } in pack (Tv_Let false [] nb arg_term (hoist_and_apply head rest ((pack (Tv_Var (binder_to_namedv nb)), Q_Explicit)::hoisted_args))) let specialize_abspat_continuation' (continuation: abspat_continuation) (solution_term:term) : Tac term = let mk_arg_term argspec = abspat_arg_of_abspat_argspec solution_term argspec in let argspecs, body = continuation in hoist_and_apply body (map mk_arg_term argspecs) [] (** Specialize a continuation of type ``abspat_continuation``. This yields a quoted function taking a matching solution and running its body with appropriate bindings. **) let specialize_abspat_continuation (continuation: abspat_continuation) : Tac term = let solution_binder = fresh_binder (`matching_solution) in let solution_term = pack (Tv_Var (binder_to_namedv solution_binder)) in let applied = specialize_abspat_continuation' continuation solution_term in let thunked = pack (Tv_Abs solution_binder applied) in debug ("Specialized into " ^ (term_to_string thunked)); let normalized = beta_reduce thunked in debug ("… which reduces to " ^ (term_to_string normalized)); thunked (** Interpret a continuation of type ``abspat_continuation``. This yields a function taking a matching solution and running the body of the continuation with appropriate bindings. **) let interp_abspat_continuation (a:Type0) (continuation: abspat_continuation) : Tac (matching_solution -> Tac a) = let applied = specialize_abspat_continuation continuation in unquote #(matching_solution -> Tac a) applied /// Putting it all together /// ======================= /// /// We now have all we need to use pattern-matching, short of a few convenience functions: (** Construct a matching problem from an abspat. **) let interp_abspat #a (abspat: a) : Tac (matching_problem * abspat_continuation) = matching_problem_of_abs (quote abspat) (** Construct an solve a matching problem. This higher-order function isn't very usable on its own — it's mostly a

abspat: a -> k: (_: FStar.Tactics.PatternMatching.abspat_continuation -> FStar.Tactics.Effect.Tac (_: FStar.Tactics.PatternMatching.matching_solution -> FStar.Tactics.Effect.Tac b)) -> FStar.Tactics.Effect.Tac b

FStar.Tactics.Effect.Tac

let match_abspat #b #a (abspat: a) (k: (abspat_continuation -> Tac (matching_solution -> Tac b))) : Tac b =

let goal = cur_goal () in let hypotheses = vars_of_env (cur_env ()) in let problem, continuation = interp_abspat abspat in solve_mp problem hypotheses goal (k continuation)

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.mustfail

val mustfail (#a: _) (t: (unit -> Tac a)) (message: string) : Tac unit

val mustfail (#a: _) (t: (unit -> Tac a)) (message: string) : Tac unit

let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> ()

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions)

t: (_: Prims.unit -> FStar.Tactics.Effect.Tac a) -> message: Prims.string -> FStar.Tactics.Effect.Tac Prims.unit

FStar.Tactics.Effect.Tac

let mustfail #a (t: (unit -> Tac a)) (message: string) : Tac unit =

match trytac t with | Some _ -> fail message | None -> ()

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.string_of_match_exception

val string_of_match_exception : _: FStar.Tactics.PatternMatching.match_exception -> FStar.Tactics.Effect.Tac Prims.string

let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)"

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp"

_: FStar.Tactics.PatternMatching.match_exception -> FStar.Tactics.Effect.Tac Prims.string

FStar.Tactics.Effect.Tac

let string_of_match_exception =

function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp \226\128\166``, or ``goal \226\128\166``)"

MerkleTree.Spec.fst

MerkleTree.Spec.mt_verify

val mt_verify: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> p:(path #hsz n) -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> padded_hash #hsz -> GTot prop

val mt_verify: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> p:(path #hsz n) -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> padded_hash #hsz -> GTot prop

let mt_verify #hsz #f #n p idx h rt = rt == mt_verify_ #_ #f p idx h

module MerkleTree.Spec open FStar.Classical open FStar.Mul open FStar.Seq module S = FStar.Seq #set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 10" // For SHA2_256, this is is a sequence of 32 bytes // These are secret bytes, hence not an eqtype type hash (#hsz:pos) = b:Spec.Hash.Definitions.bytes { Seq.length b = hsz } type hash_fun_t (#hsz:pos) = hash #hsz -> hash #hsz -> GTot (hash #hsz) val sha256_compress: hash_fun_t #32 let sha256_compress src1 src2 = let sz = Spec.Hash.Definitions.SHA2_256 in let hash_alg = Spec.Hash.Definitions.SHA2_256 in let acc = Spec.Agile.Hash.init hash_alg in let acc = Spec.Agile.Hash.update hash_alg acc (S.append src1 src2) in Spec.Agile.Hash.finish hash_alg acc () /// For simplicity, we will specify the root for a sequence of [i] /// tags where [i <= 2^n] as the root of a full binary tree with [2^n] /// leaves obtained by padding the sequence with dummies. This /// requires extending the definitions of hashes and hash functions. Our /// extended definition of hash justifies skipping any concrete /// computation on dummies. noeq type padded_hash #hsz = | HRaw: hr:hash #hsz -> padded_hash #hsz | HPad // right padding to make the size of a Merkle tree a power of 2 val padded_hash_fun: (#hsz:pos) -> (f:hash_fun_t #hsz) -> (lh:padded_hash #hsz) -> (rh:padded_hash #hsz) -> GTot (padded_hash #hsz) let padded_hash_fun #hsz f lh rh = allow_inversion (padded_hash #hsz); match lh, rh with | HPad , _ -> HPad | _ , HPad -> lh | HRaw lhr, HRaw rhr -> HRaw (f lhr rhr) noextract val hashes (#hsz:pos): Type0 let hashes #hsz = S.seq (padded_hash #hsz) type merkle_tree (#hsz:pos) n = hs:hashes #hsz {S.length hs = pow2 n} val mt_get: #hsz:pos -> #n:nat -> mt:merkle_tree #hsz n -> idx:nat{idx < pow2 n} -> GTot (padded_hash #hsz) let mt_get #_ #_ mt idx = S.index mt idx unfold let op_String_Access (#hsz:pos) = S.index #(padded_hash #hsz) #push-options "--max_fuel 1" val mt_left: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1) let mt_left #_ #n mt = S.slice mt 0 (pow2 (n-1)) val mt_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> merkle_tree #hsz (n-1) let mt_right #_ #n mt = S.slice mt (pow2 (n-1)) (pow2 n) val mt_left_right: #hsz:pos -> #n:pos -> mt:merkle_tree #hsz n -> Lemma (S.equal mt (mt_left mt @| mt_right mt)) let mt_left_right #_ #_ mt = () val hs_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> GTot (nhs:hashes #hsz {S.length nhs = n}) let rec hs_next_lv #hsz #f #n hs = if n = 0 then S.empty else S.cons (padded_hash_fun #hsz f hs.[0] hs.[1]) (hs_next_lv #hsz #f #(n-1) (S.slice hs 2 (S.length hs))) val hs_next_lv_index: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat{i < n} -> Lemma ((hs_next_lv #hsz #f #n hs).[i] == padded_hash_fun #hsz f hs.[2 * i] hs.[2 * i + 1]) let rec hs_next_lv_index #hsz #f #n hs i = if n = 0 || i = 0 then () else hs_next_lv_index #hsz #f #(n - 1) (S.slice hs 2 (S.length hs)) (i - 1) val hs_next_lv_slice: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> hs:hashes{S.length hs = 2 * n} -> i:nat -> j:nat{i <= j && j <= n} -> Lemma (requires True) (ensures S.equal (hs_next_lv #hsz #f #(j - i) (S.slice hs (2 * i) (2 * j))) (S.slice (hs_next_lv #hsz #f #n hs) i j)) (decreases (j - i)) let rec hs_next_lv_slice #hsz #f #n hs i j = if i = j then () else begin let x = S.slice hs (2 * i) (2 * j) in assert (S.equal (hs_next_lv #hsz #f #(j - i) x) (S.cons (padded_hash_fun #hsz f x.[0] x.[1]) (hs_next_lv #hsz #f #(j - i - 1) (S.slice x 2 (S.length x))))); hs_next_lv_slice #hsz #f #n hs (i + 1) j; hs_next_lv_index #hsz #f #n hs i end val mt_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> GTot (merkle_tree #hsz (n-1)) let mt_next_lv #_ #f #n mt = hs_next_lv #_ #f #(pow2 (n-1)) mt val mt_next_lv_mt_left: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n -> Lemma (S.equal (mt_next_lv #_ #f #_ (mt_left mt)) (mt_left (mt_next_lv #_ #f #_ mt))) let mt_next_lv_mt_left #hsz #f #n mt = hs_next_lv_slice #_ #f #(pow2 (n-1)) mt 0 (pow2 (n-2)) val mt_next_lv_mt_right: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat{1 < n} -> mt:merkle_tree #hsz n -> Lemma (S.equal (mt_next_lv #_ #f #_ (mt_right mt)) (mt_right (mt_next_lv #_ #f #_ mt))) let mt_next_lv_mt_right #hsz #f #n mt = hs_next_lv_slice #hsz #f #(pow2 (n-1)) mt (pow2 (n-2)) (pow2 (n-1)) val hs_next_lv_equiv: #hsz:pos -> #f:hash_fun_t #hsz -> j:nat -> n:pos{j <= 2 * n} -> hs1:hashes{S.length hs1 = 2 * n} -> hs2:hashes{S.length hs2 = 2 * n} -> Lemma (requires S.equal (S.slice hs1 0 j) (S.slice hs2 0 j)) (ensures S.equal (S.slice (hs_next_lv #hsz #f #n hs1) 0 (j / 2)) (S.slice (hs_next_lv #hsz #f #n hs2) 0 (j / 2))) let hs_next_lv_equiv #hsz #f j n hs1 hs2 = forall_intro (hs_next_lv_index #_ #f #n hs1); forall_intro (hs_next_lv_index #_ #f #n hs2); let hs1' = hs_next_lv #_ #f #n hs1 in let hs2' = hs_next_lv #_ #f #n hs2 in assert (forall (i:nat{i < j / 2}). hs1'.[i] == padded_hash_fun #hsz f hs1.[2 * i] hs1.[2 * i + 1]); assert (forall (i:nat{i < j / 2}). hs2'.[i] == padded_hash_fun #hsz f hs2.[2 * i] hs2.[2 * i + 1]); assert (forall (i:nat{i < j}). (S.slice hs1 0 j).[i] == (S.slice hs2 0 j).[i]); assert (forall (i:nat{i < j}). hs1.[i] == hs2.[i]); assert (forall (i:nat{i < j / 2}). hs1.[2 * i] == hs2.[2 * i]); assert (forall (i:nat{i < j / 2}). hs1.[2 * i + 1] == hs2.[2 * i + 1]); assert (forall (i:nat{i < j / 2}). hs1'.[i] == hs2'.[i]) val mt_next_lv_equiv: #hsz:pos -> #f:hash_fun_t #hsz -> j:nat -> n:pos{j <= pow2 n} -> mt1:merkle_tree #hsz n -> mt2:merkle_tree #hsz n -> Lemma (requires S.equal (S.slice mt1 0 j) (S.slice mt2 0 j)) (ensures S.equal (S.slice (mt_next_lv #_ #f #_ mt1) 0 (j / 2)) (S.slice (mt_next_lv #_ #f #_ mt2) 0 (j / 2))) let mt_next_lv_equiv #hsz #f j n mt1 mt2 = hs_next_lv_equiv #_ #f j (pow2 (n-1)) mt1 mt2 val hs_next_rel: #hsz:pos -> #f:hash_fun_t #hsz -> n:nat -> hs:hashes #hsz {S.length hs = 2 * n} -> nhs:hashes #hsz {S.length nhs = n} -> GTot Type0 let hs_next_rel #hsz #f n hs nhs = forall (i:nat{i < n}). S.index nhs i == padded_hash_fun #hsz f (S.index hs (2 * i)) (S.index hs (2 * i + 1)) val mt_next_rel: #hsz:pos -> #f:hash_fun_t #hsz -> n:pos -> mt:merkle_tree #hsz n -> nmt:merkle_tree #hsz (n - 1) -> GTot Type0 let mt_next_rel #hsz #f n mt nmt = hs_next_rel #hsz #f (pow2 (n-1)) mt nmt val hs_next_rel_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> n:nat -> hs:hashes{S.length hs = 2 * n} -> nhs:hashes{S.length nhs = n} -> Lemma (requires hs_next_rel #_ #f n hs nhs) (ensures S.equal nhs (hs_next_lv #_ #f #n hs)) let rec hs_next_rel_next_lv #hsz #f n hs nhs = if n = 0 then () else hs_next_rel_next_lv #_ #f (n - 1) (S.slice hs 2 (S.length hs)) (S.slice nhs 1 (S.length nhs)) val mt_next_rel_next_lv: #hsz:pos -> #f:hash_fun_t #hsz -> n:pos -> mt:merkle_tree #hsz n -> nmt:merkle_tree (n - 1) -> Lemma (requires mt_next_rel #_ #f n mt nmt) (ensures S.equal nmt (mt_next_lv #_ #f mt)) let mt_next_rel_next_lv #hsz #f n mt nmt = hs_next_rel_next_lv #_ #f (pow2 (n-1)) mt nmt val mt_next_rel_upd_even: #hsz:pos -> #f:hash_fun_t #hsz -> n:pos -> mt:merkle_tree #hsz n -> nmt:merkle_tree (n - 1) -> i:nat{i < pow2 (n-1)} -> v:padded_hash -> Lemma (requires mt_next_rel #_ #f n mt nmt) (ensures mt_next_rel #_ #f n (S.upd mt (2 * i) v) (S.upd nmt i (padded_hash_fun #hsz f v (S.index mt (2 * i + 1))))) let mt_next_rel_upd_even #hsz #f n mt nmt i v = () #push-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1" val mt_next_rel_upd_even_pad: #hsz:pos -> #f:hash_fun_t #hsz -> n:pos -> mt:merkle_tree #hsz n -> nmt:merkle_tree #hsz (n - 1) -> i:nat{i < pow2 (n-1)} -> v:padded_hash #hsz -> Lemma (requires (mt_next_rel #_ #f n mt nmt) /\ (S.index mt (2 * i + 1) == HPad)) (ensures (mt_next_rel #_ #f n (S.upd mt (2 * i) v) (S.upd nmt i v))) let mt_next_rel_upd_even_pad #hsz #f n mt nmt i v = () #pop-options val mt_next_rel_upd_odd: #hsz:pos -> #f:hash_fun_t #hsz -> n:pos -> mt:merkle_tree #hsz n -> nmt:merkle_tree (n - 1) -> i:nat{i < pow2 (n-1)} -> v:padded_hash -> Lemma (requires mt_next_rel #_ #f n mt nmt) (ensures mt_next_rel #_ #f n (S.upd mt (2 * i + 1) v) (S.upd nmt i (padded_hash_fun #_ f (S.index mt (2 * i)) v))) let mt_next_rel_upd_odd #hsz #f n mt nmt i v = () // fournet: just [root]? val mt_get_root: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> mt:merkle_tree #hsz n -> GTot (padded_hash #hsz) let rec mt_get_root #hsz #f #n mt = if n = 0 then mt.[0] else mt_get_root #_ #f (mt_next_lv #_ #f mt) #push-options "--initial_fuel 2 --max_fuel 2" val mt_get_root_step: #hsz:pos -> #f:hash_fun_t #hsz -> #n:pos -> mt:merkle_tree #hsz n -> Lemma (mt_get_root #_ #f mt == padded_hash_fun #_ f (mt_get_root #_ #f (mt_left mt)) (mt_get_root #_ #f (mt_right mt))) let rec mt_get_root_step #hsz #f #n mt = if n = 1 then () else begin mt_get_root_step #_ #f (mt_next_lv #_ #f mt); mt_next_lv_mt_left #_ #f mt; mt_next_lv_mt_right #_ #f mt end #pop-options type path #hsz n = S.lseq (padded_hash #hsz) n /// We first specify full paths, including padding. val mt_get_path: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat -> mt:merkle_tree #hsz n -> i:nat{i < pow2 n} -> GTot (path #hsz n) let rec mt_get_path #hsz #f #n t i = if n = 0 then S.empty else S.cons (if i % 2 = 0 then t.[i + 1] else t.[i - 1]) (mt_get_path #_ #f (mt_next_lv #_ #f t) (i / 2)) val mt_verify_: #hsz:pos -> #f:hash_fun_t #hsz ->#n:nat -> p:path #hsz n -> idx:nat{idx < pow2 n} -> padded_hash #hsz -> GTot (padded_hash #hsz) let rec mt_verify_ #hsz #f #n p idx h = if n = 0 then h else mt_verify_ #_ #f #(n-1) (S.tail p) (idx / 2) (if idx % 2 = 0 then padded_hash_fun #_ f h (S.head p) else padded_hash_fun #_ f (S.head p) h) val mt_verify: #hsz:pos -> #f:hash_fun_t #hsz -> #n:nat ->

p: MerkleTree.Spec.path n -> idx: Prims.nat{idx < Prims.pow2 n} -> h: MerkleTree.Spec.padded_hash -> rt: MerkleTree.Spec.padded_hash -> Prims.GTot Prims.prop

Prims.GTot

let mt_verify #hsz #f #n p idx h rt =

rt == mt_verify_ #_ #f p idx h

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.fetch_eq_side

val fetch_eq_side: Prims.unit -> Tac (term * term)

val fetch_eq_side: Prims.unit -> Tac (term * term)

let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level"

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation:

_: Prims.unit -> FStar.Tactics.Effect.Tac (FStar.Tactics.NamedView.term * FStar.Tactics.NamedView.term)

FStar.Tactics.Effect.Tac

let fetch_eq_side () : Tac (term * term) =

let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level"

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.string_of_matching_problem

val string_of_matching_problem : mp: FStar.Tactics.PatternMatching.matching_problem -> Prims.string

let string_of_matching_problem mp = let vars = String.concat ", " mp.mp_vars in let hyps = String.concat "\n " (List.Tot.Base.map (fun (nm, pat) -> nm ^ ": " ^ (string_of_pattern pat)) mp.mp_hyps) in let goal = match mp.mp_goal with | None -> "_" | Some pat -> string_of_pattern pat in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ "\n" ^ " goal: " ^ goal ^ " }"

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp" let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)" /// The exception monad /// ------------------- noeq type match_res a = | Success of a | Failure of match_exception let return #a (x: a) : match_res a = Success x let (let?) (#a #b: Type) (f: match_res a) (g: a -> Tac (match_res b)) : Tac (match_res b) = match f with | Success aa -> g aa | Failure ex -> Failure ex let raise #a (ex: match_exception) : match_res a = Failure ex /// Liftings /// -------- /// /// There's a natural lifting from the exception monad into the tactic effect: let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern interpretation /// ====================== /// /// This section implement pattern-matching. This is strictly a one term, one /// pattern implementation — handling cases in which mutliple hypotheses match /// the same pattern is done later. type bindings = list (varname * term) let string_of_bindings (bindings: bindings) = String.concat "\n" (map (fun (nm, tm) -> (">> " ^ nm ^ ": " ^ term_to_string tm)) bindings) (** Match a pattern against a term. `cur_bindings` is a list of bindings collected while matching previous parts of the pattern. Returns a result in the exception monad. **) let rec interp_pattern_aux (pat: pattern) (cur_bindings: bindings) (tm:term) : Tac (match_res bindings) = let interp_var (v: varname) cur_bindings tm = match List.Tot.Base.assoc v cur_bindings with | Some tm' -> if term_eq tm tm' then return cur_bindings else raise (NonLinearMismatch (v, tm, tm')) | None -> return ((v, tm) :: cur_bindings) in let interp_qn (qn: qn) cur_bindings tm = match inspect tm with | Tv_UInst fv _ | Tv_FVar fv -> if fv_to_string fv = qn then return cur_bindings else raise (NameMismatch (qn, (fv_to_string fv))) | _ -> raise (SimpleMismatch (pat, tm)) in let interp_type cur_bindings tm = match inspect tm with | Tv_Type _ -> return cur_bindings | _ -> raise (SimpleMismatch (pat, tm)) in let interp_app (p_hd p_arg: (p:pattern{p << pat})) cur_bindings tm = match inspect tm with | Tv_App hd (arg, _) -> let? with_hd = interp_pattern_aux p_hd cur_bindings hd in let? with_arg = interp_pattern_aux p_arg with_hd arg in return with_arg | _ -> raise (SimpleMismatch (pat, tm)) in match pat with | PVar var -> interp_var var cur_bindings tm | PQn qn -> interp_qn qn cur_bindings tm | PType -> interp_type cur_bindings tm | PApp p_hd p_arg -> interp_app p_hd p_arg cur_bindings tm (** Match a pattern `pat` against a term. Returns a result in the exception monad. **) let interp_pattern (pat: pattern) : term -> Tac (match_res bindings) = fun (tm: term) -> let? rev_bindings = interp_pattern_aux pat [] tm in return (List.Tot.Base.rev rev_bindings) (** Match a term `tm` against a pattern `pat`. Raises an exception if the match fails. This is mostly useful for debugging: use ``mgw`` to capture matches. **) let match_term pat (tm : term) : Tac bindings = match interp_pattern pat (norm_term [] tm) with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex) /// Pattern-matching problems /// ========================= /// /// Generalizing past single-term single-pattern problems, we obtain the /// following notions of pattern-matching problems and solutions: let debug msg : Tac unit = () // print msg /// Definitions /// ----------- let absvar = binding type hypothesis = binding /// A matching problem is composed of holes (``mp_vars``), hypothesis patterns /// (``mp_hyps``), and a goal pattern (``mp_goal``). noeq type matching_problem = { mp_vars: list varname; mp_hyps: list (varname * pattern); mp_goal: option pattern }

mp: FStar.Tactics.PatternMatching.matching_problem -> Prims.string

Prims.Tot

let string_of_matching_problem mp =

let vars = String.concat ", " mp.mp_vars in let hyps = String.concat "\n " (List.Tot.Base.map (fun (nm, pat) -> nm ^ ": " ^ (string_of_pattern pat)) mp.mp_hyps) in let goal = match mp.mp_goal with | None -> "_" | Some pat -> string_of_pattern pat in "\n{ vars: " ^ vars ^ "\n" ^ " hyps: " ^ hyps ^ "\n" ^ " goal: " ^ goal ^ " }"

FStar.Tactics.PatternMatching.fst

FStar.Tactics.PatternMatching.lift_exn_tactic

val lift_exn_tactic (#a #b: _) (f: (a -> match_res b)) (aa: a) : Tac b

val lift_exn_tactic (#a #b: _) (f: (a -> match_res b)) (aa: a) : Tac b

let lift_exn_tactic #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex)

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) /// ========================== /// Pattern-matching tactics /// ========================== /// /// :Author: Clément Pit-Claudel /// :Contact: [email protected] /// :Date: 2017-10-13 module FStar.Tactics.PatternMatching open FStar.Tactics.V2 /// Contents /// ======== /// /// 1 Contents /// 2 Motivation /// 3 Some utility functions /// 4 Pattern types /// 5 Pattern matching exceptions /// 5.1 Types of exceptions /// 5.2 The exception monad /// 5.3 Liftings /// 6 Pattern interpretation /// 7 Pattern-matching problems /// 7.1 Definitions /// 7.2 Resolution /// 8 A DSL for pattern-matching /// 8.1 Pattern notations /// 8.2 Problem notations /// 8.3 Continuations /// 9 Putting it all together /// 10 Examples /// 10.1 Simple examples /// 10.2 A real-life example /// 11 Possible extensions /// 12 Notes /// /// Motivation /// ========== /// /// Suppose you have a goal of the form ``squash (a == b)``. How do you capture /// `a` and `b` for further inspection? /// /// Here's a basic (but cumbersome!) implementation: let fetch_eq_side () : Tac (term * term) = let g = cur_goal () in match inspect g with | Tv_App squash (g, _) -> (match inspect squash with | Tv_UInst squash _ | Tv_FVar squash -> if fv_to_string squash = flatten_name squash_qn then (match inspect g with | Tv_App eq_type_x (y, _) -> (match inspect eq_type_x with | Tv_App eq_type (x, _) -> (match inspect eq_type with | Tv_App eq (typ, _) -> (match inspect eq with | Tv_UInst eq _ | Tv_FVar eq -> if fv_to_string eq = flatten_name eq2_qn then (x, y) else fail "not an equality" | _ -> fail "not an app2 of fvar: ") | _ -> fail "not an app3") | _ -> fail "not an app2") | _ -> fail "not an app under squash") else fail "not a squash" | _ -> fail "not an app of fvar at top level") | _ -> fail "not an app at top level" /// …and here's how you could use it: (* let _ = *) (* assert_by_tactic (1 + 1 == 2) *) (* (fun () -> let l, r = fetch_eq_side () in *) (* print (term_to_string l ^ " / " ^ term_to_string r)) *) /// This file defines pattern-matching primitives that let you write the same /// thing like this… /// /// .. code:: fstar /// /// let fetch_eq_side' #a () : Tac (term * term) = /// gpm (fun (left right: a) (g: pm_goal (squash (left == right))) -> /// (quote left, quote right) <: Tac (term * term)) /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (fun () -> let l, r = fetch_eq_side' #int () in /// print (term_to_string l ^ " / " ^ term_to_string r)) /// /// …or, more succinctly, like this: /// /// .. code:: fstar /// /// let _ = /// assert_by_tactic (1 + 1 == 2) /// (gpm (fun (left right: int) (g: pm_goal (squash (left == right))) -> /// let l, r = quote left, quote right in /// print (term_to_string l ^ " / " ^ term_to_string r) <: Tac unit)) /// Some utility functions /// ====================== /// /// (Skip over this part on a quick read — these are just convenience functions) (** Ensure that tactic `t` fails. **) let mustfail #a (t: unit -> Tac a) (message: string) : Tac unit = match trytac t with | Some _ -> fail message | None -> () /// The following two tactics are needed because of issues with the ``Tac`` /// effect. let implies_intro' () : Tac unit = let _ = implies_intro () in () let repeat' #a (f: unit -> Tac a) : Tac unit = let _ = repeat f in () let and_elim' (h: binding) : Tac unit = and_elim (pack (Tv_Var h)); clear h (** Use a hypothesis at type a to satisfy a goal at type squash a *) let exact_hyp (a: Type0) (h: namedv) : Tac unit = let hd = quote (FStar.Squash.return_squash #a) in exact (mk_app hd [((pack (Tv_Var h)), Q_Explicit)]) (** Use a hypothesis h (of type a) to satisfy a goal at type a *) let exact_hyp' (h: namedv): Tac unit = exact (pack (Tv_Var h)) /// Pattern types /// ============= /// /// Patterns are defined using a simple inductive type, mirroring the structure /// of ``term_view``. type varname = string type qn = string type pattern = | PVar: name: varname -> pattern | PQn: qn: qn -> pattern | PType: pattern | PApp: hd: pattern -> arg: pattern -> pattern let desc_of_pattern = function | PVar _ -> "a variable" | PQn qn -> "a constant (" ^ qn ^ ")" | PType -> "Type" | PApp _ _ -> "a function application" let rec string_of_pattern = function | PVar x -> "?" ^ x | PQn qn -> qn | PType -> "Type" | PApp l r -> "(" ^ string_of_pattern l ^ " " ^ string_of_pattern r ^ ")" /// Pattern matching exceptions /// =========================== /// /// Pattern-matching is defined as a pure, monadic function (because of issues /// with combining DM4F effects, but also because it helps with debugging). /// This section defines the exception monad. /// /// Types of exceptions /// ------------------- noeq type match_exception = | NameMismatch of qn * qn | SimpleMismatch of pattern * term | NonLinearMismatch of varname * term * term | UnsupportedTermInPattern of term | IncorrectTypeInAbsPatBinder of typ let term_head t : Tac string = match inspect t with | Tv_Var bv -> "Tv_Var" | Tv_BVar fv -> "Tv_BVar" | Tv_FVar fv -> "Tv_FVar" | Tv_UInst _ _ -> "Tv_UInst" | Tv_App f x -> "Tv_App" | Tv_Abs x t -> "Tv_Abs" | Tv_Arrow x t -> "Tv_Arrow" | Tv_Type _ -> "Tv_Type" | Tv_Refine x t -> "Tv_Refine" | Tv_Const cst -> "Tv_Const" | Tv_Uvar i t -> "Tv_Uvar" | Tv_Let r attrs b t1 t2 -> "Tv_Let" | Tv_Match t _ branches -> "Tv_Match" | Tv_AscribedT _ _ _ _ -> "Tv_AscribedT" | Tv_AscribedC _ _ _ _ -> "Tv_AscribedC" | Tv_Unknown -> "Tv_Unknown" | Tv_Unsupp -> "Tv_Unsupp" let string_of_match_exception = function | NameMismatch (qn1, qn2) -> "Match failure (name mismatch): expecting " ^ qn1 ^ ", found " ^ qn2 | SimpleMismatch (pat, tm) -> "Match failure (sort mismatch): expecting " ^ desc_of_pattern pat ^ ", got " ^ term_to_string tm | NonLinearMismatch (nm, t1, t2) -> "Match failure (nonlinear mismatch): variable " ^ nm ^ " needs to match both " ^ (term_to_string t1) ^ " and " ^ (term_to_string t2) | UnsupportedTermInPattern tm -> "Match failure (unsupported term in pattern): " ^ term_to_string tm ^ " (" ^ term_head tm ^ ")" | IncorrectTypeInAbsPatBinder typ -> "Incorrect type in pattern-matching binder: " ^ term_to_string typ ^ " (use one of ``var``, ``hyp …``, or ``goal …``)" /// The exception monad /// ------------------- noeq type match_res a = | Success of a | Failure of match_exception let return #a (x: a) : match_res a = Success x let (let?) (#a #b: Type) (f: match_res a) (g: a -> Tac (match_res b)) : Tac (match_res b) = match f with | Success aa -> g aa | Failure ex -> Failure ex let raise #a (ex: match_exception) : match_res a = Failure ex /// Liftings /// -------- /// /// There's a natural lifting from the exception monad into the tactic effect: let lift_exn_tac #a #b (f: a -> match_res b) (aa: a) : Tac b = match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex)

f: (_: a -> FStar.Tactics.PatternMatching.match_res b) -> aa: a -> FStar.Tactics.Effect.Tac b

FStar.Tactics.Effect.Tac

let lift_exn_tactic #a #b (f: (a -> match_res b)) (aa: a) : Tac b =

match f aa with | Success bb -> bb | Failure ex -> Tactics.fail (string_of_match_exception ex)

Pulse.Elaborate.Core.fst

Pulse.Elaborate.Core.elab_st_typing

val elab_st_typing (#g: env) (#t: st_term) (#c: comp) (d: st_typing g t c) : Tot R.term (decreases d)

val elab_st_typing (#g: env) (#t: st_term) (#c: comp) (d: st_typing g t c) : Tot R.term (decreases d)

let rec elab_st_typing (#g:env) (#t:st_term) (#c:comp) (d:st_typing g t c) : Tot R.term (decreases d) = match d with // | T_Tot _ t _ _ -> elab_term t | T_Abs _ x qual b _u body _c ty_typing body_typing -> let ty = elab_term b.binder_ty in let ppname = b.binder_ppname.name in let body = elab_st_typing body_typing in mk_abs_with_name ppname ty (elab_qual qual) (RT.close_term body x) //this closure should be provably redundant by strengthening the conditions on x | T_STApp _ head _ qual _ arg _ _ | T_STGhostApp _ head _ qual _ arg _ _ _ _ -> let head = elab_term head in let arg = elab_term arg in R.mk_app head [(arg, elab_qual qual)] | T_Return _ c use_eq u ty t post _ _ _ _ -> let ru = u in let rty = elab_term ty in let rt = elab_term t in let rp = elab_term post in let rp = mk_abs rty R.Q_Explicit rp in (match c, use_eq with | STT, true -> mk_stt_return ru rty rt rp | STT, false -> mk_stt_return_noeq ru rty rt rp | STT_Atomic, true -> mk_stt_atomic_return ru rty rt rp | STT_Atomic, false -> mk_stt_atomic_return_noeq ru rty rt rp | STT_Ghost, true -> mk_stt_ghost_return ru rty rt rp | STT_Ghost, false -> mk_stt_ghost_return_noeq ru rty rt rp) | T_Bind _ e1 e2 c1 c2 b x c e1_typing t_typing e2_typing bc -> let e1 = elab_st_typing e1_typing in let e2 = elab_st_typing e2_typing in let ty1 = elab_term (comp_res c1) in elab_bind bc e1 (mk_abs_with_name b.binder_ppname.name ty1 R.Q_Explicit (RT.close_term e2 x)) | T_BindFn _ _ _ c1 c2 b x e1_typing _u t_typing e2_typing c2_typing -> let e1 = elab_st_typing e1_typing in let e2 = elab_st_typing e2_typing in let ty1 = elab_term (comp_res c1) in RT.mk_let RT.pp_name_default e1 ty1 (RT.close_term e2 x) | T_Frame _ _ c frame _frame_typing e_typing -> let e = elab_st_typing e_typing in elab_frame c frame e | T_Equiv _ _ c1 c2 e_typing (ST_TotEquiv _ _ _ _ _ _) -> let e = elab_st_typing e_typing in e | T_Equiv _ _ c1 c2 e_typing _ -> let e = elab_st_typing e_typing in elab_sub c1 c2 e | T_Sub _ _ c1 c2 e_typing d_sub -> let e = elab_st_typing e_typing in let (| coercion, _ |) = elab_st_sub d_sub in R.mk_e_app coercion [e] | T_Lift _ _ c1 c2 e_typing lc -> let e = elab_st_typing e_typing in elab_lift lc e | T_If _ b _ _ _ _ _ e1_typing e2_typing _c_typing -> let rb = elab_term b in let re1 = elab_st_typing e1_typing in let re2 = elab_st_typing e2_typing in RT.mk_if rb re1 re2 | T_Match _ _ _ sc _ _ _ _ _ brty _ -> let sc = elab_term sc in let brs = elab_branches brty in R.pack_ln (R.Tv_Match sc None brs) | T_IntroPure _ p _ _ -> let head = tm_pureapp (tm_fvar (as_fv (mk_pulse_lib_core_lid "intro_pure"))) None p in let arg = (`()) in R.mk_app (elab_term head) [(arg, elab_qual None)] | T_ElimExists _ u t p _ d_t d_exists -> let ru = u in let rt = elab_term t in let rp = elab_term p in mk_elim_exists ru rt (mk_abs rt R.Q_Explicit rp) | T_IntroExists _ u b p e _ _ _ -> let ru = u in let rt = elab_term b.binder_ty in let rp = elab_term p in let re = elab_term e in mk_intro_exists ru rt (mk_abs rt R.Q_Explicit rp) re | T_While _ inv _ _ _ cond_typing body_typing -> let inv = elab_term inv in let cond = elab_st_typing cond_typing in let body = elab_st_typing body_typing in mk_while (mk_abs bool_tm R.Q_Explicit inv) cond body | T_Par _ eL cL eR cR _ _ _ eL_typing eR_typing -> let ru = comp_u cL in let raL = elab_term (comp_res cL) in let raR = elab_term (comp_res cR) in let rpreL = elab_term (comp_pre cL) in let rpostL = elab_term (comp_post cL) in let rpreR = elab_term (comp_pre cR) in let rpostR = elab_term (comp_post cR) in let reL = elab_st_typing eL_typing in let reR = elab_st_typing eR_typing in mk_par ru raL raR rpreL (mk_abs raL R.Q_Explicit rpostL) rpreR (mk_abs raR R.Q_Explicit rpostR) reL reR | T_Rewrite _ p q _ _ -> let rp = elab_term p in let rq = elab_term q in mk_rewrite rp rq | T_WithLocal _ _ init _ init_t c x _ _ _ body_typing -> let rret_u = comp_u c in let ra = elab_term init_t in let rinit = elab_term init in let rret_t = elab_term (comp_res c) in let rpre = elab_term (comp_pre c) in let rpost = mk_abs rret_t R.Q_Explicit (elab_term (comp_post c)) in let rbody = elab_st_typing body_typing in let rbody = RT.close_term rbody x in let rbody = mk_abs (mk_ref ra) R.Q_Explicit rbody in mk_withlocal rret_u ra rinit rpre rret_t rpost rbody | T_WithLocalArray _ _ init len _ init_t c x _ _ _ _ body_typing -> let rret_u = comp_u c in let ra = elab_term init_t in let rinit = elab_term init in let rlen = elab_term len in let rret_t = elab_term (comp_res c) in let rpre = elab_term (comp_pre c) in let rpost = mk_abs rret_t R.Q_Explicit (elab_term (comp_post c)) in let rbody = elab_st_typing body_typing in let rbody = RT.close_term rbody x in let rbody = mk_abs (mk_array ra) R.Q_Explicit rbody in mk_withlocalarray rret_u ra rinit rlen rpre rret_t rpost rbody | T_Admit _ {u;res;pre;post} c _ -> let ru = u in let rres = elab_term res in let rpre = elab_term pre in let rpost = elab_term post in let rpost = mk_abs rres R.Q_Explicit rpost in (match c with | STT -> mk_stt_admit ru rres rpre rpost | STT_Atomic -> mk_stt_atomic_admit ru rres rpre rpost | STT_Ghost -> mk_stt_ghost_admit ru rres rpre rpost) | T_Unreachable _ _ _ _ _ -> `("IOU: elab_st_typing of T_Unreachable") | T_WithInv _ _ _ _ _ _ _ _ _ -> `("IOU: elab_st_typing of T_WithInv") and elab_br (#g:env) (#c:comp_st) (#sc_u:universe) (#sc_ty:typ) (#sc:term) (#p:pattern) (#e:st_term) (d : br_typing g sc_u sc_ty sc p e c) : Tot R.branch (decreases d) = let TBR _ _ _ _ _ _ _ _ bs _ _ _ ed = d in let e = elab_st_typing ed in (elab_pat p, e) and elab_branches (#g:env) (#c:comp_st) (#sc_u:universe) (#sc_ty:typ) (#sc:term) (#brs:list branch) (d : brs_typing g sc_u sc_ty sc brs c) : Tot (list R.branch) (decreases d) = match d with | TBRS_0 _ -> [] | TBRS_1 _ p e bd _ d' -> elab_br bd :: elab_branches d'

(* 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.Elaborate.Core module RT = FStar.Reflection.Typing module R = FStar.Reflection.V2 module L = FStar.List.Tot module T = FStar.Tactics.V2 open FStar.List.Tot open Pulse.Syntax open Pulse.Elaborate.Pure open Pulse.Typing module RU = Pulse.RuntimeUtils open Pulse.Reflection.Util let elab_frame (c:comp_st) (frame:term) (e:R.term) = let u = comp_u c in let ty = elab_term (comp_res c) in let pre = elab_term (comp_pre c) in let post = elab_term (comp_post c) in if C_ST? c then mk_frame_stt u ty pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e else if C_STAtomic? c then let opened = elab_term (comp_inames c) in mk_frame_stt_atomic u ty opened pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e else mk_frame_stt_ghost u ty pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e let elab_sub (c1 c2:comp_st) (e:R.term) = let ty = elab_term (comp_res c1) in let u = comp_u c1 in let pre1 = elab_term (comp_pre c1) in let pre2 = elab_term (comp_pre c2) in let post1 = mk_abs ty R.Q_Explicit (elab_term (comp_post c1)) in let post2 = mk_abs ty R.Q_Explicit (elab_term (comp_post c2)) in if C_ST? c1 then mk_sub_stt u ty pre1 pre2 post1 post2 e else if C_STAtomic? c1 then let opened = elab_term (comp_inames c1) in mk_sub_stt_atomic u ty opened pre1 pre2 post1 post2 e else mk_sub_stt_ghost u ty pre1 pre2 post1 post2 e let elab_bind #g #x #c1 #c2 #c (bc:bind_comp g x c1 c2 c) (e1 e2:R.term) : R.term = let t1 = elab_term (comp_res c1) in let t2 = elab_term (comp_res c2) in match c1 with | C_ST _ -> mk_bind_stt (comp_u c1) (comp_u c2) t1 t2 (elab_term (comp_pre c1)) (mk_abs t1 R.Q_Explicit (elab_term (comp_post c1))) (mk_abs t2 R.Q_Explicit (elab_term (comp_post c2))) e1 e2 | C_STGhost _ -> mk_bind_ghost (comp_u c1) (comp_u c2) t1 t2 (elab_term (comp_pre c1)) (mk_abs t1 R.Q_Explicit (elab_term (comp_post c1))) (mk_abs t2 R.Q_Explicit (elab_term (comp_post c2))) e1 e2 | C_STAtomic inames obs1 _ -> let C_STAtomic _ obs2 _ = c2 in mk_bind_atomic (comp_u c1) (comp_u c2) (elab_observability obs1) (elab_observability obs2) (elab_term (comp_inames c1)) t1 t2 (elab_term (comp_pre c1)) (mk_abs t1 R.Q_Explicit (elab_term (comp_post c1))) (mk_abs t2 R.Q_Explicit (elab_term (comp_post c2))) e1 e2 let elab_lift #g #c1 #c2 (d:lift_comp g c1 c2) (e:R.term) : Tot R.term = match d with | Lift_STAtomic_ST _ _ -> let t = elab_term (comp_res c1) in mk_lift_atomic_stt (comp_u c1) (elab_term (comp_res c1)) t (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e | Lift_Observability _ c o2 -> let t = elab_term (comp_res c1) in mk_lift_observability (comp_u c1) (elab_observability (C_STAtomic?.obs c)) (elab_observability o2) (elab_term (comp_inames c1)) t (elab_term (comp_pre c1)) (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e | Lift_Ghost_Neutral _ _ (| reveal_a, reveal_a_typing |) -> let t = elab_term (comp_res c1) in mk_lift_ghost_neutral (comp_u c1) t (elab_term (comp_pre c1)) (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e (elab_term reveal_a) | Lift_Neutral_Ghost _ c -> let t = elab_term (comp_res c1) in mk_lift_neutral_ghost (comp_u c1) t (elab_term (comp_pre c1)) (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e let intro_pure_tm (p:term) = let open Pulse.Reflection.Util in wtag (Some STT_Ghost) (Tm_STApp { head = tm_pureapp (tm_fvar (as_fv (mk_pulse_lib_core_lid "intro_pure"))) None p; arg_qual = None; arg = tm_fstar (`()) Range.range_0 }) let simple_arr (t1 t2 : R.term) : R.term = let b = R.pack_binder { sort = t1; ppname = Sealed.seal "x"; qual = R.Q_Explicit; attrs = [] } in R.pack_ln (R.Tv_Arrow b (R.pack_comp (R.C_Total t2))) let elab_st_sub (#g:env) (#c1 #c2 : comp) (d_sub : st_sub g c1 c2) : Tot (t:R.term & RT.tot_typing (elab_env g) t (simple_arr (elab_comp c1) (elab_comp c2))) = RU.magic_s "elab_st_sub"

d: Pulse.Typing.st_typing g t c -> Prims.Tot FStar.Stubs.Reflection.Types.term

Prims.Tot

let rec elab_st_typing (#g: env) (#t: st_term) (#c: comp) (d: st_typing g t c) : Tot R.term (decreases d) =

match d with | T_Abs _ x qual b _u body _c ty_typing body_typing -> let ty = elab_term b.binder_ty in let ppname = b.binder_ppname.name in let body = elab_st_typing body_typing in mk_abs_with_name ppname ty (elab_qual qual) (RT.close_term body x) | T_STApp _ head _ qual _ arg _ _ | T_STGhostApp _ head _ qual _ arg _ _ _ _ -> let head = elab_term head in let arg = elab_term arg in R.mk_app head [(arg, elab_qual qual)] | T_Return _ c use_eq u ty t post _ _ _ _ -> let ru = u in let rty = elab_term ty in let rt = elab_term t in let rp = elab_term post in let rp = mk_abs rty R.Q_Explicit rp in (match c, use_eq with | STT, true -> mk_stt_return ru rty rt rp | STT, false -> mk_stt_return_noeq ru rty rt rp | STT_Atomic, true -> mk_stt_atomic_return ru rty rt rp | STT_Atomic, false -> mk_stt_atomic_return_noeq ru rty rt rp | STT_Ghost, true -> mk_stt_ghost_return ru rty rt rp | STT_Ghost, false -> mk_stt_ghost_return_noeq ru rty rt rp) | T_Bind _ e1 e2 c1 c2 b x c e1_typing t_typing e2_typing bc -> let e1 = elab_st_typing e1_typing in let e2 = elab_st_typing e2_typing in let ty1 = elab_term (comp_res c1) in elab_bind bc e1 (mk_abs_with_name b.binder_ppname.name ty1 R.Q_Explicit (RT.close_term e2 x)) | T_BindFn _ _ _ c1 c2 b x e1_typing _u t_typing e2_typing c2_typing -> let e1 = elab_st_typing e1_typing in let e2 = elab_st_typing e2_typing in let ty1 = elab_term (comp_res c1) in RT.mk_let RT.pp_name_default e1 ty1 (RT.close_term e2 x) | T_Frame _ _ c frame _frame_typing e_typing -> let e = elab_st_typing e_typing in elab_frame c frame e | T_Equiv _ _ c1 c2 e_typing (ST_TotEquiv _ _ _ _ _ _) -> let e = elab_st_typing e_typing in e | T_Equiv _ _ c1 c2 e_typing _ -> let e = elab_st_typing e_typing in elab_sub c1 c2 e | T_Sub _ _ c1 c2 e_typing d_sub -> let e = elab_st_typing e_typing in let (| coercion , _ |) = elab_st_sub d_sub in R.mk_e_app coercion [e] | T_Lift _ _ c1 c2 e_typing lc -> let e = elab_st_typing e_typing in elab_lift lc e | T_If _ b _ _ _ _ _ e1_typing e2_typing _c_typing -> let rb = elab_term b in let re1 = elab_st_typing e1_typing in let re2 = elab_st_typing e2_typing in RT.mk_if rb re1 re2 | T_Match _ _ _ sc _ _ _ _ _ brty _ -> let sc = elab_term sc in let brs = elab_branches brty in R.pack_ln (R.Tv_Match sc None brs) | T_IntroPure _ p _ _ -> let head = tm_pureapp (tm_fvar (as_fv (mk_pulse_lib_core_lid "intro_pure"))) None p in let arg = (`()) in R.mk_app (elab_term head) [(arg, elab_qual None)] | T_ElimExists _ u t p _ d_t d_exists -> let ru = u in let rt = elab_term t in let rp = elab_term p in mk_elim_exists ru rt (mk_abs rt R.Q_Explicit rp) | T_IntroExists _ u b p e _ _ _ -> let ru = u in let rt = elab_term b.binder_ty in let rp = elab_term p in let re = elab_term e in mk_intro_exists ru rt (mk_abs rt R.Q_Explicit rp) re | T_While _ inv _ _ _ cond_typing body_typing -> let inv = elab_term inv in let cond = elab_st_typing cond_typing in let body = elab_st_typing body_typing in mk_while (mk_abs bool_tm R.Q_Explicit inv) cond body | T_Par _ eL cL eR cR _ _ _ eL_typing eR_typing -> let ru = comp_u cL in let raL = elab_term (comp_res cL) in let raR = elab_term (comp_res cR) in let rpreL = elab_term (comp_pre cL) in let rpostL = elab_term (comp_post cL) in let rpreR = elab_term (comp_pre cR) in let rpostR = elab_term (comp_post cR) in let reL = elab_st_typing eL_typing in let reR = elab_st_typing eR_typing in mk_par ru raL raR rpreL (mk_abs raL R.Q_Explicit rpostL) rpreR (mk_abs raR R.Q_Explicit rpostR) reL reR | T_Rewrite _ p q _ _ -> let rp = elab_term p in let rq = elab_term q in mk_rewrite rp rq | T_WithLocal _ _ init _ init_t c x _ _ _ body_typing -> let rret_u = comp_u c in let ra = elab_term init_t in let rinit = elab_term init in let rret_t = elab_term (comp_res c) in let rpre = elab_term (comp_pre c) in let rpost = mk_abs rret_t R.Q_Explicit (elab_term (comp_post c)) in let rbody = elab_st_typing body_typing in let rbody = RT.close_term rbody x in let rbody = mk_abs (mk_ref ra) R.Q_Explicit rbody in mk_withlocal rret_u ra rinit rpre rret_t rpost rbody | T_WithLocalArray _ _ init len _ init_t c x _ _ _ _ body_typing -> let rret_u = comp_u c in let ra = elab_term init_t in let rinit = elab_term init in let rlen = elab_term len in let rret_t = elab_term (comp_res c) in let rpre = elab_term (comp_pre c) in let rpost = mk_abs rret_t R.Q_Explicit (elab_term (comp_post c)) in let rbody = elab_st_typing body_typing in let rbody = RT.close_term rbody x in let rbody = mk_abs (mk_array ra) R.Q_Explicit rbody in mk_withlocalarray rret_u ra rinit rlen rpre rret_t rpost rbody | T_Admit _ { u = u ; res = res ; pre = pre ; post = post } c _ -> let ru = u in let rres = elab_term res in let rpre = elab_term pre in let rpost = elab_term post in let rpost = mk_abs rres R.Q_Explicit rpost in (match c with | STT -> mk_stt_admit ru rres rpre rpost | STT_Atomic -> mk_stt_atomic_admit ru rres rpre rpost | STT_Ghost -> mk_stt_ghost_admit ru rres rpre rpost) | T_Unreachable _ _ _ _ _ -> `("IOU: elab_st_typing of T_Unreachable") | T_WithInv _ _ _ _ _ _ _ _ _ -> `("IOU: elab_st_typing of T_WithInv")

Pulse.Elaborate.Core.fst

Pulse.Elaborate.Core.elab_branches

val elab_branches (#g: env) (#c: comp_st) (#sc_u: universe) (#sc_ty: typ) (#sc: term) (#brs: list branch) (d: brs_typing g sc_u sc_ty sc brs c) : Tot (list R.branch) (decreases d)

val elab_branches (#g: env) (#c: comp_st) (#sc_u: universe) (#sc_ty: typ) (#sc: term) (#brs: list branch) (d: brs_typing g sc_u sc_ty sc brs c) : Tot (list R.branch) (decreases d)

let rec elab_st_typing (#g:env) (#t:st_term) (#c:comp) (d:st_typing g t c) : Tot R.term (decreases d) = match d with // | T_Tot _ t _ _ -> elab_term t | T_Abs _ x qual b _u body _c ty_typing body_typing -> let ty = elab_term b.binder_ty in let ppname = b.binder_ppname.name in let body = elab_st_typing body_typing in mk_abs_with_name ppname ty (elab_qual qual) (RT.close_term body x) //this closure should be provably redundant by strengthening the conditions on x | T_STApp _ head _ qual _ arg _ _ | T_STGhostApp _ head _ qual _ arg _ _ _ _ -> let head = elab_term head in let arg = elab_term arg in R.mk_app head [(arg, elab_qual qual)] | T_Return _ c use_eq u ty t post _ _ _ _ -> let ru = u in let rty = elab_term ty in let rt = elab_term t in let rp = elab_term post in let rp = mk_abs rty R.Q_Explicit rp in (match c, use_eq with | STT, true -> mk_stt_return ru rty rt rp | STT, false -> mk_stt_return_noeq ru rty rt rp | STT_Atomic, true -> mk_stt_atomic_return ru rty rt rp | STT_Atomic, false -> mk_stt_atomic_return_noeq ru rty rt rp | STT_Ghost, true -> mk_stt_ghost_return ru rty rt rp | STT_Ghost, false -> mk_stt_ghost_return_noeq ru rty rt rp) | T_Bind _ e1 e2 c1 c2 b x c e1_typing t_typing e2_typing bc -> let e1 = elab_st_typing e1_typing in let e2 = elab_st_typing e2_typing in let ty1 = elab_term (comp_res c1) in elab_bind bc e1 (mk_abs_with_name b.binder_ppname.name ty1 R.Q_Explicit (RT.close_term e2 x)) | T_BindFn _ _ _ c1 c2 b x e1_typing _u t_typing e2_typing c2_typing -> let e1 = elab_st_typing e1_typing in let e2 = elab_st_typing e2_typing in let ty1 = elab_term (comp_res c1) in RT.mk_let RT.pp_name_default e1 ty1 (RT.close_term e2 x) | T_Frame _ _ c frame _frame_typing e_typing -> let e = elab_st_typing e_typing in elab_frame c frame e | T_Equiv _ _ c1 c2 e_typing (ST_TotEquiv _ _ _ _ _ _) -> let e = elab_st_typing e_typing in e | T_Equiv _ _ c1 c2 e_typing _ -> let e = elab_st_typing e_typing in elab_sub c1 c2 e | T_Sub _ _ c1 c2 e_typing d_sub -> let e = elab_st_typing e_typing in let (| coercion, _ |) = elab_st_sub d_sub in R.mk_e_app coercion [e] | T_Lift _ _ c1 c2 e_typing lc -> let e = elab_st_typing e_typing in elab_lift lc e | T_If _ b _ _ _ _ _ e1_typing e2_typing _c_typing -> let rb = elab_term b in let re1 = elab_st_typing e1_typing in let re2 = elab_st_typing e2_typing in RT.mk_if rb re1 re2 | T_Match _ _ _ sc _ _ _ _ _ brty _ -> let sc = elab_term sc in let brs = elab_branches brty in R.pack_ln (R.Tv_Match sc None brs) | T_IntroPure _ p _ _ -> let head = tm_pureapp (tm_fvar (as_fv (mk_pulse_lib_core_lid "intro_pure"))) None p in let arg = (`()) in R.mk_app (elab_term head) [(arg, elab_qual None)] | T_ElimExists _ u t p _ d_t d_exists -> let ru = u in let rt = elab_term t in let rp = elab_term p in mk_elim_exists ru rt (mk_abs rt R.Q_Explicit rp) | T_IntroExists _ u b p e _ _ _ -> let ru = u in let rt = elab_term b.binder_ty in let rp = elab_term p in let re = elab_term e in mk_intro_exists ru rt (mk_abs rt R.Q_Explicit rp) re | T_While _ inv _ _ _ cond_typing body_typing -> let inv = elab_term inv in let cond = elab_st_typing cond_typing in let body = elab_st_typing body_typing in mk_while (mk_abs bool_tm R.Q_Explicit inv) cond body | T_Par _ eL cL eR cR _ _ _ eL_typing eR_typing -> let ru = comp_u cL in let raL = elab_term (comp_res cL) in let raR = elab_term (comp_res cR) in let rpreL = elab_term (comp_pre cL) in let rpostL = elab_term (comp_post cL) in let rpreR = elab_term (comp_pre cR) in let rpostR = elab_term (comp_post cR) in let reL = elab_st_typing eL_typing in let reR = elab_st_typing eR_typing in mk_par ru raL raR rpreL (mk_abs raL R.Q_Explicit rpostL) rpreR (mk_abs raR R.Q_Explicit rpostR) reL reR | T_Rewrite _ p q _ _ -> let rp = elab_term p in let rq = elab_term q in mk_rewrite rp rq | T_WithLocal _ _ init _ init_t c x _ _ _ body_typing -> let rret_u = comp_u c in let ra = elab_term init_t in let rinit = elab_term init in let rret_t = elab_term (comp_res c) in let rpre = elab_term (comp_pre c) in let rpost = mk_abs rret_t R.Q_Explicit (elab_term (comp_post c)) in let rbody = elab_st_typing body_typing in let rbody = RT.close_term rbody x in let rbody = mk_abs (mk_ref ra) R.Q_Explicit rbody in mk_withlocal rret_u ra rinit rpre rret_t rpost rbody | T_WithLocalArray _ _ init len _ init_t c x _ _ _ _ body_typing -> let rret_u = comp_u c in let ra = elab_term init_t in let rinit = elab_term init in let rlen = elab_term len in let rret_t = elab_term (comp_res c) in let rpre = elab_term (comp_pre c) in let rpost = mk_abs rret_t R.Q_Explicit (elab_term (comp_post c)) in let rbody = elab_st_typing body_typing in let rbody = RT.close_term rbody x in let rbody = mk_abs (mk_array ra) R.Q_Explicit rbody in mk_withlocalarray rret_u ra rinit rlen rpre rret_t rpost rbody | T_Admit _ {u;res;pre;post} c _ -> let ru = u in let rres = elab_term res in let rpre = elab_term pre in let rpost = elab_term post in let rpost = mk_abs rres R.Q_Explicit rpost in (match c with | STT -> mk_stt_admit ru rres rpre rpost | STT_Atomic -> mk_stt_atomic_admit ru rres rpre rpost | STT_Ghost -> mk_stt_ghost_admit ru rres rpre rpost) | T_Unreachable _ _ _ _ _ -> `("IOU: elab_st_typing of T_Unreachable") | T_WithInv _ _ _ _ _ _ _ _ _ -> `("IOU: elab_st_typing of T_WithInv") and elab_br (#g:env) (#c:comp_st) (#sc_u:universe) (#sc_ty:typ) (#sc:term) (#p:pattern) (#e:st_term) (d : br_typing g sc_u sc_ty sc p e c) : Tot R.branch (decreases d) = let TBR _ _ _ _ _ _ _ _ bs _ _ _ ed = d in let e = elab_st_typing ed in (elab_pat p, e) and elab_branches (#g:env) (#c:comp_st) (#sc_u:universe) (#sc_ty:typ) (#sc:term) (#brs:list branch) (d : brs_typing g sc_u sc_ty sc brs c) : Tot (list R.branch) (decreases d) = match d with | TBRS_0 _ -> [] | TBRS_1 _ p e bd _ d' -> elab_br bd :: elab_branches d'

(* 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.Elaborate.Core module RT = FStar.Reflection.Typing module R = FStar.Reflection.V2 module L = FStar.List.Tot module T = FStar.Tactics.V2 open FStar.List.Tot open Pulse.Syntax open Pulse.Elaborate.Pure open Pulse.Typing module RU = Pulse.RuntimeUtils open Pulse.Reflection.Util let elab_frame (c:comp_st) (frame:term) (e:R.term) = let u = comp_u c in let ty = elab_term (comp_res c) in let pre = elab_term (comp_pre c) in let post = elab_term (comp_post c) in if C_ST? c then mk_frame_stt u ty pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e else if C_STAtomic? c then let opened = elab_term (comp_inames c) in mk_frame_stt_atomic u ty opened pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e else mk_frame_stt_ghost u ty pre (mk_abs ty R.Q_Explicit post) (elab_term frame) e let elab_sub (c1 c2:comp_st) (e:R.term) = let ty = elab_term (comp_res c1) in let u = comp_u c1 in let pre1 = elab_term (comp_pre c1) in let pre2 = elab_term (comp_pre c2) in let post1 = mk_abs ty R.Q_Explicit (elab_term (comp_post c1)) in let post2 = mk_abs ty R.Q_Explicit (elab_term (comp_post c2)) in if C_ST? c1 then mk_sub_stt u ty pre1 pre2 post1 post2 e else if C_STAtomic? c1 then let opened = elab_term (comp_inames c1) in mk_sub_stt_atomic u ty opened pre1 pre2 post1 post2 e else mk_sub_stt_ghost u ty pre1 pre2 post1 post2 e let elab_bind #g #x #c1 #c2 #c (bc:bind_comp g x c1 c2 c) (e1 e2:R.term) : R.term = let t1 = elab_term (comp_res c1) in let t2 = elab_term (comp_res c2) in match c1 with | C_ST _ -> mk_bind_stt (comp_u c1) (comp_u c2) t1 t2 (elab_term (comp_pre c1)) (mk_abs t1 R.Q_Explicit (elab_term (comp_post c1))) (mk_abs t2 R.Q_Explicit (elab_term (comp_post c2))) e1 e2 | C_STGhost _ -> mk_bind_ghost (comp_u c1) (comp_u c2) t1 t2 (elab_term (comp_pre c1)) (mk_abs t1 R.Q_Explicit (elab_term (comp_post c1))) (mk_abs t2 R.Q_Explicit (elab_term (comp_post c2))) e1 e2 | C_STAtomic inames obs1 _ -> let C_STAtomic _ obs2 _ = c2 in mk_bind_atomic (comp_u c1) (comp_u c2) (elab_observability obs1) (elab_observability obs2) (elab_term (comp_inames c1)) t1 t2 (elab_term (comp_pre c1)) (mk_abs t1 R.Q_Explicit (elab_term (comp_post c1))) (mk_abs t2 R.Q_Explicit (elab_term (comp_post c2))) e1 e2 let elab_lift #g #c1 #c2 (d:lift_comp g c1 c2) (e:R.term) : Tot R.term = match d with | Lift_STAtomic_ST _ _ -> let t = elab_term (comp_res c1) in mk_lift_atomic_stt (comp_u c1) (elab_term (comp_res c1)) t (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e | Lift_Observability _ c o2 -> let t = elab_term (comp_res c1) in mk_lift_observability (comp_u c1) (elab_observability (C_STAtomic?.obs c)) (elab_observability o2) (elab_term (comp_inames c1)) t (elab_term (comp_pre c1)) (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e | Lift_Ghost_Neutral _ _ (| reveal_a, reveal_a_typing |) -> let t = elab_term (comp_res c1) in mk_lift_ghost_neutral (comp_u c1) t (elab_term (comp_pre c1)) (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e (elab_term reveal_a) | Lift_Neutral_Ghost _ c -> let t = elab_term (comp_res c1) in mk_lift_neutral_ghost (comp_u c1) t (elab_term (comp_pre c1)) (mk_abs t R.Q_Explicit (elab_term (comp_post c1))) e let intro_pure_tm (p:term) = let open Pulse.Reflection.Util in wtag (Some STT_Ghost) (Tm_STApp { head = tm_pureapp (tm_fvar (as_fv (mk_pulse_lib_core_lid "intro_pure"))) None p; arg_qual = None; arg = tm_fstar (`()) Range.range_0 }) let simple_arr (t1 t2 : R.term) : R.term = let b = R.pack_binder { sort = t1; ppname = Sealed.seal "x"; qual = R.Q_Explicit; attrs = [] } in R.pack_ln (R.Tv_Arrow b (R.pack_comp (R.C_Total t2))) let elab_st_sub (#g:env) (#c1 #c2 : comp) (d_sub : st_sub g c1 c2) : Tot (t:R.term & RT.tot_typing (elab_env g) t (simple_arr (elab_comp c1) (elab_comp c2))) = RU.magic_s "elab_st_sub"

d: Pulse.Typing.brs_typing g sc_u sc_ty sc brs c -> Prims.Tot (Prims.list FStar.Stubs.Reflection.V2.Data.branch)

Prims.Tot